@galacean/engine-core 1.2.0-beta.5 → 1.2.0-beta.6

package/dist/main.js

@@ -3984,6 +3984,7 @@ var ShaderFactory = /*#__PURE__*/ function() {
         var program = this._glProgram;
         var uniformInfos = this._getUniformInfos();
         var attributeInfos = this._getAttributeInfos();
+        var basicResources = this._engine._basicResources;
         uniformInfos.forEach(function(param) {
             var name = param.name, size = param.size, type = param.type;
             var shaderUniform = new ShaderUniform(_this._engine);
@@ -4077,16 +4078,16 @@ var ShaderFactory = /*#__PURE__*/ function() {
                     var defaultTexture;
                     switch(type){
                         case gl.SAMPLER_2D:
-                            defaultTexture = _this._engine._magentaTexture2D;
+                            defaultTexture = basicResources.whiteTexture2D;
                             break;
                         case gl.SAMPLER_CUBE:
-                            defaultTexture = _this._engine._magentaTextureCube;
+                            defaultTexture = basicResources.whiteTextureCube;
                             break;
                         case gl.UNSIGNED_INT_SAMPLER_2D:
-                            defaultTexture = _this._engine._uintMagentaTexture2D;
+                            defaultTexture = basicResources.uintWhiteTexture2D;
                             break;
                         case gl.SAMPLER_2D_ARRAY:
-                            defaultTexture = _this._engine._magentaTexture2DArray;
+                            defaultTexture = basicResources.whiteTexture2DArray;
                             break;
                         case gl.SAMPLER_2D_SHADOW:
                             defaultTexture = _this._engine._depthTexture2D;
@@ -6416,14 +6417,15 @@ SlicedSpriteAssembler = __decorate([
         }
         this._endLoop(swapFn);
     };
-    _proto.forEachAndClean = function forEachAndClean(callbackFn) {
+    _proto.forEachAndClean = function forEachAndClean(callbackFn, swapFn) {
         this._startLoop();
+        var preEnd = this.length;
         var elements = this._elements;
-        for(var i = 0, n = this.length; i < n; i++){
+        for(var i = 0, n = preEnd; i < n; i++){
             var element = elements[i];
             element && callbackFn(element);
         }
-        this._endLoopAndClear();
+        this._endLoopAndClean(preEnd, elements, swapFn);
     };
     _proto.sort = function sort(compareFn) {
         Utils._quickSort(this._elements, 0, this.length, compareFn);
@@ -6456,9 +6458,17 @@ SlicedSpriteAssembler = __decorate([
             this._blankCount = 0;
         }
     };
-    _proto._endLoopAndClear = function _endLoopAndClear() {
+    _proto._endLoopAndClean = function _endLoopAndClean(preEnd, elements, swapFn) {
+        var index = 0;
+        for(var i = preEnd, n = this.length; i < n; i++){
+            var element = elements[i];
+            if (!element) continue;
+            elements[index] = element;
+            swapFn(element, index);
+            index++;
+        }
         this._isLooping = false;
-        this.length = 0;
+        this.length = index;
         this._blankCount = 0;
     };
     return DisorderedArray;
@@ -15860,6 +15870,26 @@ var BaseMaterial = /*#__PURE__*/ function(Material1) {
         this.blitMesh = this._createBlitMesh(engine, vertices);
         this.flipYBlitMesh = this._createBlitMesh(engine, flipYVertices);
         this.blitMaterial = blitMaterial;
+        // Create white and magenta textures
+        var whitePixel = new Uint8Array([
+            255,
+            255,
+            255,
+            255
+        ]);
+        this.whiteTexture2D = this._create1x1Texture(engine, 0, exports.TextureFormat.R8G8B8A8, whitePixel);
+        this.whiteTextureCube = this._create1x1Texture(engine, 1, exports.TextureFormat.R8G8B8A8, whitePixel);
+        var isWebGL2 = engine._hardwareRenderer.isWebGL2;
+        if (isWebGL2) {
+            this.whiteTexture2DArray = this._create1x1Texture(engine, 2, exports.TextureFormat.R8G8B8A8, whitePixel);
+            var whitePixel32 = new Uint32Array([
+                255,
+                255,
+                255,
+                255
+            ]);
+            this.uintWhiteTexture2D = this._create1x1Texture(engine, 0, exports.TextureFormat.R32G32B32A32_UInt, whitePixel32);
+        }
     }
     var _proto = BasicResources.prototype;
     _proto._createBlitMesh = function _createBlitMesh(engine, vertices) {
@@ -15872,8 +15902,63 @@ var BaseMaterial = /*#__PURE__*/ function(Material1) {
         mesh.addSubMesh(0, 4, exports.MeshTopology.TriangleStrip);
         return mesh;
     };
+    _proto._create1x1Texture = function _create1x1Texture(engine, type, format, pixel) {
+        var texture;
+        switch(type){
+            case 0:
+                var texture2D = new Texture2D(engine, 1, 1, format, false);
+                texture2D.setPixelBuffer(pixel);
+                texture = texture2D;
+                break;
+            case 2:
+                var texture2DArray = new Texture2DArray(engine, 1, 1, 1, format, false);
+                texture2DArray.setPixelBuffer(0, pixel);
+                texture = texture2DArray;
+                break;
+            case 1:
+                var textureCube = new TextureCube(engine, 1, format, false);
+                for(var i = 0; i < 6; i++){
+                    textureCube.setPixelBuffer(exports.TextureCubeFace.PositiveX + i, pixel);
+                }
+                texture = textureCube;
+                break;
+            default:
+                throw "Invalid texture type";
+        }
+        texture.isGCIgnored = true;
+        engine.resourceManager.addContentRestorer(new /*#__PURE__*/ (function(ContentRestorer) {
+            _inherits(_class, ContentRestorer);
+            function _class() {
+                return ContentRestorer.call(this, texture);
+            }
+            var _proto = _class.prototype;
+            _proto.restoreContent = function restoreContent() {
+                switch(type){
+                    case 0:
+                        this.resource.setPixelBuffer(pixel);
+                        break;
+                    case 2:
+                        this.resource.setPixelBuffer(0, pixel);
+                        break;
+                    case 1:
+                        for(var i = 0; i < 6; i++){
+                            this.resource.setPixelBuffer(exports.TextureCubeFace.PositiveX + i, pixel);
+                        }
+                        break;
+                }
+            };
+            return _class;
+        }(ContentRestorer))());
+        return texture;
+    };
     return BasicResources;
 }();
+var TextureType;
+(function(TextureType) {
+    TextureType[TextureType["Texture2D"] = 0] = "Texture2D";
+    TextureType[TextureType["TextureCube"] = 1] = "TextureCube";
+    TextureType[TextureType["Texture2DArray"] = 2] = "Texture2DArray";
+})(TextureType || (TextureType = {}));
 
 /**
  * @internal
@@ -20406,7 +20491,6 @@ ShaderPool.init();
             _this.xrManager = new XRManager();
             _this.xrManager._initialize(_assert_this_initialized(_this), xrDevice);
         }
-        _this._initMagentaTextures(hardwareRenderer);
         if (!hardwareRenderer.canIUse(exports.GLCapabilityType.depthTexture)) {
             _this._macroCollection.enable(Engine._noDepthTextureMacro);
         } else {
@@ -20642,99 +20726,6 @@ ShaderPool.init();
     };
     /**
    * @internal
-   * Standalone for CanvasRenderer plugin.
-   */ _proto._initMagentaTextures = function _initMagentaTextures(hardwareRenderer) {
-        var whitePixel = new Uint8Array([
-            255,
-            255,
-            255,
-            255
-        ]);
-        var whiteTexture2D = new Texture2D(this, 1, 1, exports.TextureFormat.R8G8B8A8, false);
-        whiteTexture2D.setPixelBuffer(whitePixel);
-        whiteTexture2D.isGCIgnored = true;
-        var magentaPixel = new Uint8Array([
-            255,
-            0,
-            255,
-            255
-        ]);
-        var magentaTexture2D = new Texture2D(this, 1, 1, exports.TextureFormat.R8G8B8A8, false);
-        magentaTexture2D.setPixelBuffer(magentaPixel);
-        magentaTexture2D.isGCIgnored = true;
-        this.resourceManager.addContentRestorer(new /*#__PURE__*/ (function(ContentRestorer) {
-            _inherits(_class, ContentRestorer);
-            function _class() {
-                return ContentRestorer.call(this, magentaTexture2D);
-            }
-            var _proto = _class.prototype;
-            _proto.restoreContent = function restoreContent() {
-                this.resource.setPixelBuffer(magentaPixel);
-            };
-            return _class;
-        }(ContentRestorer))());
-        var magentaTextureCube = new TextureCube(this, 1, exports.TextureFormat.R8G8B8A8, false);
-        for(var i = 0; i < 6; i++){
-            magentaTextureCube.setPixelBuffer(exports.TextureCubeFace.PositiveX + i, magentaPixel);
-        }
-        magentaTextureCube.isGCIgnored = true;
-        this.resourceManager.addContentRestorer(new /*#__PURE__*/ (function(ContentRestorer) {
-            _inherits(_class, ContentRestorer);
-            function _class() {
-                return ContentRestorer.call(this, magentaTextureCube);
-            }
-            var _proto = _class.prototype;
-            _proto.restoreContent = function restoreContent() {
-                for(var i = 0; i < 6; i++){
-                    this.resource.setPixelBuffer(exports.TextureCubeFace.PositiveX + i, magentaPixel);
-                }
-            };
-            return _class;
-        }(ContentRestorer))());
-        this._whiteTexture2D = whiteTexture2D;
-        this._magentaTexture2D = magentaTexture2D;
-        this._magentaTextureCube = magentaTextureCube;
-        if (hardwareRenderer.isWebGL2) {
-            var magentaPixel32 = new Uint32Array([
-                255,
-                0,
-                255,
-                255
-            ]);
-            var uintMagentaTexture2D = new Texture2D(this, 1, 1, exports.TextureFormat.R32G32B32A32_UInt, false);
-            uintMagentaTexture2D.setPixelBuffer(magentaPixel32);
-            uintMagentaTexture2D.isGCIgnored = true;
-            this.resourceManager.addContentRestorer(new /*#__PURE__*/ (function(ContentRestorer) {
-                _inherits(_class, ContentRestorer);
-                function _class() {
-                    return ContentRestorer.call(this, uintMagentaTexture2D);
-                }
-                var _proto = _class.prototype;
-                _proto.restoreContent = function restoreContent() {
-                    this.resource.setPixelBuffer(magentaPixel32);
-                };
-                return _class;
-            }(ContentRestorer))());
-            var magentaTexture2DArray = new Texture2DArray(this, 1, 1, 1, exports.TextureFormat.R8G8B8A8, false);
-            magentaTexture2DArray.setPixelBuffer(0, magentaPixel);
-            magentaTexture2DArray.isGCIgnored = true;
-            this.resourceManager.addContentRestorer(new /*#__PURE__*/ (function(ContentRestorer) {
-                _inherits(_class, ContentRestorer);
-                function _class() {
-                    return ContentRestorer.call(this, magentaTexture2DArray);
-                }
-                var _proto = _class.prototype;
-                _proto.restoreContent = function restoreContent() {
-                    this.resource.setPixelBuffer(0, magentaPixel);
-                };
-                return _class;
-            }(ContentRestorer))());
-            this._uintMagentaTexture2D = uintMagentaTexture2D;
-            this._magentaTexture2DArray = magentaTexture2DArray;
-        }
-    };
-    /**
-   * @internal
    */ _proto._pendingGC = function _pendingGC() {
         if (this._frameInProcess) {
             this._waitingGC = true;
@@ -21374,6 +21365,8 @@ ShaderPool.init();
                 script._started = true;
                 _this.removeOnStartScript(script);
                 script.onStart();
+            }, function(element, index) {
+                element._onStartIndex = index;
             });
         }
     };
@@ -24314,7 +24307,7 @@ var /**
             depthOnlyPass.onConfig(camera);
             depthOnlyPass.onRender(context, cullingResults);
         } else {
-            camera.shaderData.setTexture(exports.Camera._cameraDepthTextureProperty, engine._whiteTexture2D);
+            camera.shaderData.setTexture(exports.Camera._cameraDepthTextureProperty, engine._basicResources.whiteTexture2D);
         }
         // Check if need to create internal color texture
         var independentCanvasEnabled = camera.independentCanvasEnabled;