@galacean/engine-core 1.1.0-beta.4 → 1.1.0-beta.6

package/dist/miniprogram.js

@@ -2542,8 +2542,8 @@ var ActiveChangeFlag;
         var _this;
         _this = EngineObject1.call(this, entity.engine) || this;
         /** @internal */ _this._awoken = false;
-        _this._phasedActive = false;
         _this._phasedActiveInScene = false;
+        _this._phasedActive = false;
         _this._enabled = true;
         _this._entity = entity;
         return _this;
@@ -2675,10 +2675,10 @@ __decorate([
 ], Component.prototype, "_awoken", void 0);
 __decorate([
     ignoreClone
-], Component.prototype, "_phasedActive", void 0);
+], Component.prototype, "_phasedActiveInScene", void 0);
 __decorate([
     ignoreClone
-], Component.prototype, "_phasedActiveInScene", void 0);
+], Component.prototype, "_phasedActive", void 0);
 __decorate([
     assignmentClone
 ], Component.prototype, "_enabled", void 0);
@@ -12592,16 +12592,31 @@ var SafeLoopArray = /*#__PURE__*/ function() {
     }
     var _proto = SceneManager.prototype;
     _proto.addScene = function addScene(indexOrScene, scene) {
+        var scenes = this._scenes;
+        var index;
         if (typeof indexOrScene === "number") {
-            this._scenes.add(indexOrScene, scene);
+            if (indexOrScene < 0 || indexOrScene > scenes.length) {
+                throw "The index is out of range.";
+            }
+            index = indexOrScene;
         } else {
+            index = scenes.length;
             scene = indexOrScene;
-            this._scenes.push(scene);
         }
         if (scene.engine !== this.engine) {
             throw "The scene is not belong to this engine.";
         }
-        scene._processActive(true);
+        if (scene._sceneManager) {
+            var currentIndex = scenes.indexOf(scene);
+            if (currentIndex !== index) {
+                scenes.removeByIndex(currentIndex);
+                scenes.add(index, scene);
+            }
+        } else {
+            scene._sceneManager = this;
+            scenes.add(index, scene);
+            scene.isActive && scene._processActive(true);
+        }
     };
     /**
    * Remove scene.
@@ -12612,7 +12627,8 @@ var SafeLoopArray = /*#__PURE__*/ function() {
         if (index !== -1) {
             var removedScene = scenes.getArray()[index];
             scenes.removeByIndex(index);
-            removedScene._processActive(false);
+            scene._sceneManager = null;
+            removedScene.isActive && removedScene._processActive(false);
         }
     };
     /**
@@ -13816,9 +13832,9 @@ exports.Collider = /*#__PURE__*/ function(Component1) {
                 oldCollider.removeShape(shape);
             }
             this._shapes.push(shape);
-            this.scene.physics._addColliderShape(shape);
             shape._collider = this;
             this._nativeCollider.addShape(shape._nativeShape);
+            this._phasedActiveInScene && this.scene.physics._addColliderShape(shape);
         }
     };
     /**
@@ -13828,7 +13844,7 @@ exports.Collider = /*#__PURE__*/ function(Component1) {
         var index = this._shapes.indexOf(shape);
         if (index !== -1) {
             this._shapes.splice(index, 1);
-            this.scene.physics._removeColliderShape(shape);
+            this._phasedActiveInScene && this.scene.physics._removeColliderShape(shape);
             shape._collider = null;
             this._nativeCollider.removeShape(shape._nativeShape);
         }
@@ -13839,7 +13855,7 @@ exports.Collider = /*#__PURE__*/ function(Component1) {
         var shapes = this._shapes;
         for(var i = 0, n = shapes.length; i < n; i++){
             var shape = shapes[i];
-            this.scene.physics._removeColliderShape(shape);
+            this._phasedActiveInScene && this.scene.physics._removeColliderShape(shape);
             shape._destroy();
             this._nativeCollider.removeShape(shape._nativeShape);
         }
@@ -13864,12 +13880,22 @@ exports.Collider = /*#__PURE__*/ function(Component1) {
     /**
    * @internal
    */ _proto._onEnableInScene = function _onEnableInScene() {
-        this.scene.physics._addCollider(this);
+        var physics = this.scene.physics;
+        physics._addCollider(this);
+        var shapes = this.shapes;
+        for(var i = 0, n = shapes.length; i < n; i++){
+            physics._addColliderShape(shapes[i]);
+        }
     };
     /**
    * @internal
    */ _proto._onDisableInScene = function _onDisableInScene() {
-        this.scene.physics._removeCollider(this);
+        var physics = this.scene.physics;
+        physics._removeCollider(this);
+        var shapes = this.shapes;
+        for(var i = 0, n = shapes.length; i < n; i++){
+            physics._removeColliderShape(shapes[i]);
+        }
     };
     /**
    * @internal
@@ -14247,12 +14273,22 @@ var Collision = function Collision() {
     /**
    * @internal
    */ _proto._onEnableInScene = function _onEnableInScene() {
-        this.scene.physics._addCharacterController(this);
+        var physics = this.scene.physics;
+        physics._addCharacterController(this);
+        var shapes = this.shapes;
+        for(var i = 0, n = shapes.length; i < n; i++){
+            physics._addColliderShape(shapes[i]);
+        }
     };
     /**
    * @internal
    */ _proto._onDisableInScene = function _onDisableInScene() {
-        this.scene.physics._removeCharacterController(this);
+        var physics = this.scene.physics;
+        physics._removeCharacterController(this);
+        var shapes = this.shapes;
+        for(var i = 0, n = shapes.length; i < n; i++){
+            physics._removeColliderShape(shapes[i]);
+        }
     };
     _proto._setUpDirection = function _setUpDirection() {
         this._nativeCollider.setUpDirection(this._upDirection);
@@ -15711,8 +15747,8 @@ exports.Joint = __decorate([
                 continue;
             }
             var cameras = scene._activeCameras;
-            for(var j = 0; j < cameras.length; j++){
-                var camera = cameras[i];
+            for(var j = cameras.length - 1; j >= 0; j--){
+                var camera = cameras[j];
                 if (!camera.enabled || camera.renderTarget) {
                     continue;
                 }
@@ -16404,10 +16440,6 @@ ShaderPool.init();
         magentaMaterial.isGCIgnored = true;
         magentaMaterial.shaderData.setColor("material_BaseColor", new Color(1.0, 0.0, 1.01, 1.0));
         _this._magentaMaterial = magentaMaterial;
-        var backgroundTextureMaterial = new Material(_assert_this_initialized(_this), Shader.find("background-texture"));
-        backgroundTextureMaterial.isGCIgnored = true;
-        backgroundTextureMaterial.renderState.depthState.compareFunction = exports.CompareFunction.LessEqual;
-        _this._backgroundTextureMaterial = backgroundTextureMaterial;
         var innerSettings = _this._settings;
         var colorSpace = configuration.colorSpace || exports.ColorSpace.Linear;
         colorSpace === exports.ColorSpace.Gamma && _this._macroCollection.enable(Engine._gammaMacro);
@@ -17025,26 +17057,22 @@ ShaderPool.init();
         this./** @internal */ _textureFillMode = exports.BackgroundTextureFillMode.AspectFitHeight;
         this._texture = null;
         this._initMesh(_engine);
+        this._initMaterial(_engine);
     }
     var _proto = Background.prototype;
     /**
    * @internal
    */ _proto.destroy = function destroy() {
+        this.texture = null;
         this._mesh._addReferCount(-1);
         this._mesh = null;
-        this.texture = null;
+        this._material._addReferCount(-1);
+        this._material = null;
         this.solidColor = null;
         this.sky.destroy();
     };
     /**
    * @internal
-   * Standalone for CanvasRenderer plugin.
-   */ _proto._initMesh = function _initMesh(engine) {
-        this._mesh = this._createPlane(engine);
-        this._mesh._addReferCount(1);
-    };
-    /**
-   * @internal
    */ _proto._resizeBackgroundTexture = function _resizeBackgroundTexture() {
         if (!this._texture) {
             return;
@@ -17078,6 +17106,15 @@ ShaderPool.init();
         _backgroundTextureMesh.setPositions(positions);
         _backgroundTextureMesh.uploadData(false);
     };
+    _proto._initMesh = function _initMesh(engine) {
+        this._mesh = this._createPlane(engine);
+        this._mesh._addReferCount(1);
+    };
+    _proto._initMaterial = function _initMaterial(engine) {
+        var material = this._material = new Material(engine, Shader.find("background-texture"));
+        material.renderState.depthState.compareFunction = exports.CompareFunction.LessEqual;
+        material._addReferCount(1);
+    };
     _proto._createPlane = function _createPlane(engine) {
         var mesh = new ModelMesh(engine);
         mesh.isGCIgnored = true;
@@ -17117,7 +17154,7 @@ ShaderPool.init();
                     (_value = value) == null ? void 0 : _value._addReferCount(1);
                     (_this__texture = this._texture) == null ? void 0 : _this__texture._addReferCount(-1);
                     this._texture = value;
-                    this._engine._backgroundTextureMaterial.shaderData.setTexture("material_BaseTexture", value);
+                    this._material.shaderData.setTexture("material_BaseTexture", value);
                 }
             }
         },
@@ -17275,7 +17312,7 @@ ShaderPool.init();
         var _this = this, pendingDestroyScripts = _this._disposeDestroyScripts, disposeDestroyScripts = _this._pendingDestroyScripts;
         this._disposeDestroyScripts = disposeDestroyScripts;
         this._pendingDestroyScripts = pendingDestroyScripts;
-        length = disposeDestroyScripts.length;
+        var length = disposeDestroyScripts.length;
         if (length > 0) {
             for(var i = length - 1; i >= 0; i--){
                 disposeDestroyScripts[i].onDestroy();
@@ -18197,6 +18234,7 @@ __decorate([
         _this._fogEnd = 300;
         _this._fogDensity = 0.01;
         _this._fogParams = new miniprogram.Vector4();
+        _this._isActive = true;
         _this.name = name || "";
         var shaderData = _this.shaderData;
         shaderData._addReferCount(1);
@@ -18444,6 +18482,24 @@ __decorate([
         this._fogParams.w = density / Math.sqrt(Math.LN2);
     };
     _create_class(Scene, [
+        {
+            key: "isActive",
+            get: /**
+   * Whether the scene is active.
+   */ function get() {
+                return this._isActive;
+            },
+            set: function set(value) {
+                if (this._isActive !== value) {
+                    this._isActive = value;
+                    if (value) {
+                        this._sceneManager && this._processActive(true);
+                    } else {
+                        this._sceneManager && this._processActive(false);
+                    }
+                }
+            }
+        },
         {
             key: "shaderData",
             get: /**
@@ -18762,7 +18818,11 @@ __decorate([
    * @internal
    */ _proto._onDestroy = function _onDestroy() {
         Component1.prototype._onDestroy.call(this);
-        this.scene._componentsManager.addPendingDestroyScript(this);
+        if (this.scene) {
+            this.scene._componentsManager.addPendingDestroyScript(this);
+        } else {
+            this.onDestroy();
+        }
     };
     return Script;
 }(Component);
@@ -20312,8 +20372,8 @@ var /**
     };
     _proto._drawBackgroundTexture = function _drawBackgroundTexture(engine, background) {
         var rhi = engine._hardwareRenderer;
-        var material = engine._backgroundTextureMaterial, canvas = engine.canvas;
-        var mesh = background._mesh;
+        var canvas = engine.canvas;
+        var material = background._material, mesh = background._mesh;
         if ((this._lastCanvasSize.x !== canvas.width || this._lastCanvasSize.y !== canvas.height) && background._textureFillMode !== exports.BackgroundTextureFillMode.Fill) {
             this._lastCanvasSize.set(canvas.width, canvas.height);
             background._resizeBackgroundTexture();
@@ -20488,7 +20548,7 @@ exports.Camera = (_Camera = /*#__PURE__*/ function(Component1) {
         // Use the intersection of the near clipping plane as the origin point.
         var origin = this._innerViewportToWorldPoint(point.x, point.y, 0.0, invViewProjMat, out.origin);
         // Use the intersection of the far clipping plane as the origin point.
-        var direction = this._innerViewportToWorldPoint(point.x, point.y, 1.0, invViewProjMat, out.direction);
+        var direction = this._innerViewportToWorldPoint(point.x, point.y, 1 - miniprogram.MathUtil.zeroTolerance, invViewProjMat, out.direction);
         miniprogram.Vector3.subtract(direction, origin, direction);
         direction.normalize();
         return out;
@@ -26972,64 +27032,203 @@ exports.SunMode = void 0;
     SkyProceduralMaterial._sunSimpleMacro = ShaderMacro.getByName("MATERIAL_SUN_SIMPLE");
 })();
 
+var SubPrimitive = function SubPrimitive() {
+};
+
 /**
- * Particle Material.
- */ var ParticleMaterial = /*#__PURE__*/ function(BaseMaterial1) {
-    _inherits(ParticleMaterial, BaseMaterial1);
-    function ParticleMaterial(engine) {
+ * The rendering mode for particle renderer.
+ */ exports.ParticleRenderMode = void 0;
+(function(ParticleRenderMode) {
+    ParticleRenderMode[ParticleRenderMode[/** Render particles as billboards facing the active camera. */ "Billboard"] = 0] = "Billboard";
+    ParticleRenderMode[ParticleRenderMode[/** Stretch particles in the direction of motion. */ "StretchBillboard"] = 1] = "StretchBillboard";
+    ParticleRenderMode[ParticleRenderMode[/** Render particles as billboards always facing up along the y-Axis. */ "HorizontalBillboard"] = 2] = "HorizontalBillboard";
+    ParticleRenderMode[ParticleRenderMode[/** Render particles as billboards always facing the player, but not pitching along the x-Axis. */ "VerticalBillboard"] = 3] = "VerticalBillboard";
+    ParticleRenderMode[ParticleRenderMode[/** Render particles as meshes. */ "Mesh"] = 4] = "Mesh";
+    ParticleRenderMode[ParticleRenderMode[/** Do not render particles. */ "None"] = 5] = "None";
+})(exports.ParticleRenderMode || (exports.ParticleRenderMode = {}));
+
+exports.ParticleStopMode = void 0;
+(function(ParticleStopMode) {
+    ParticleStopMode[ParticleStopMode[/** Stop emitting new particles and clear existing particles immediately. */ "StopEmittingAndClear"] = 0] = "StopEmittingAndClear";
+    ParticleStopMode[ParticleStopMode[/** Stop emitting new particles, but keep existing particles until they expire. */ "StopEmitting"] = 1] = "StopEmitting";
+})(exports.ParticleStopMode || (exports.ParticleStopMode = {}));
+
+/**
+ * Particle Renderer Component.
+ */ var ParticleRenderer = /*#__PURE__*/ function(Renderer1) {
+    _inherits(ParticleRenderer, Renderer1);
+    function ParticleRenderer(entity) {
         var _this;
-        _this = BaseMaterial1.call(this, engine, Shader.find("particle-shader")) || this;
-        var shaderData = _this.shaderData;
-        shaderData.enableMacro("MATERIAL_OMIT_NORMAL");
-        shaderData.setColor(BaseMaterial._baseColorProp, new miniprogram.Color(1, 1, 1, 1));
-        _this.isTransparent = true;
+        _this = Renderer1.call(this, entity) || this;
+        /** Particle generator. */ _this.generator = new ParticleGenerator(_assert_this_initialized(_this));
+        /** Specifies how much particles stretch depending on their velocity. */ _this.velocityScale = 0;
+        /** How much are the particles stretched in their direction of motion, defined as the length of the particle compared to its width. */ _this.lengthScale = 2;
+        /** The pivot of particle. */ _this.pivot = new miniprogram.Vector3();
+        _this._currentRenderModeMacro = ParticleRenderer._billboardModeMacro;
+        _this.shaderData.enableMacro(ParticleRenderer._billboardModeMacro);
+        _this._supportInstancedArrays = _this.engine._hardwareRenderer.canIUse(exports.GLCapabilityType.instancedArrays);
         return _this;
     }
-    var _proto = ParticleMaterial.prototype;
+    var _proto = ParticleRenderer.prototype;
     /**
-   * @inheritdoc
-   */ _proto.clone = function clone() {
-        var dest = new ParticleMaterial(this._engine);
-        this.cloneTo(dest);
-        return dest;
+   * @internal
+   */ _proto._onEnable = function _onEnable() {
+        if (this.generator.main.playOnEnabled) {
+            this.generator.play(false);
+        }
     };
-    _create_class(ParticleMaterial, [
+    /**
+   * @internal
+   */ _proto._onDisable = function _onDisable() {
+        this.generator.stop(false, exports.ParticleStopMode.StopEmittingAndClear);
+    };
+    /**
+   * @internal
+   */ _proto._prepareRender = function _prepareRender(context) {
+        if (!this._supportInstancedArrays) {
+            return;
+        }
+        var generator = this.generator;
+        generator._update(this.engine.time.deltaTime);
+        // No particles to render
+        if (generator._firstActiveElement === generator._firstFreeElement) {
+            return;
+        }
+        Renderer1.prototype._prepareRender.call(this, context);
+    };
+    /**
+   * @internal
+   */ _proto._updateBounds = function _updateBounds(worldBounds) {
+        worldBounds.min.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
+        worldBounds.max.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
+    };
+    /**
+   * @internal
+   */ _proto._updateShaderData = function _updateShaderData(context) {
+        var shaderData = this.shaderData;
+        shaderData.setFloat(ParticleRenderer._lengthScale, this.lengthScale);
+        shaderData.setFloat(ParticleRenderer._speedScale, this.velocityScale);
+        shaderData.setFloat(ParticleRenderer._currentTime, this.generator._playTime);
+        shaderData.setVector3(ParticleRenderer._pivotOffsetProperty, this.pivot);
+        this.generator._updateShaderData(shaderData);
+    };
+    _proto._render = function _render(context) {
+        var generator = this.generator;
+        var primitive = generator._primitive;
+        if (generator._firstActiveElement < generator._firstFreeElement) {
+            primitive.instanceCount = generator._firstFreeElement - generator._firstActiveElement;
+        } else {
+            var instanceCount = generator._currentParticleCount - generator._firstActiveElement;
+            if (generator._firstFreeElement > 0) {
+                instanceCount += generator._firstFreeElement;
+            }
+            primitive.instanceCount = instanceCount;
+        }
+        var material = this.getMaterial();
+        var renderData = this._engine._renderDataPool.getFromPool();
+        renderData.setX(this, material, generator._primitive, generator._subPrimitive);
+        context.camera._renderPipeline.pushRenderData(context, renderData);
+    };
+    _proto._onDestroy = function _onDestroy() {
+        this.generator._destroy();
+    };
+    _create_class(ParticleRenderer, [
         {
-            key: "baseColor",
+            key: "renderMode",
             get: /**
-   * Base color.
+   * Specifies how particles are rendered.
    */ function get() {
-                return this.shaderData.getColor(BaseMaterial._baseColorProp);
+                return this._renderMode;
             },
             set: function set(value) {
-                var baseColor = this.shaderData.getColor(BaseMaterial._baseColorProp);
-                if (value !== baseColor) {
-                    baseColor.copyFrom(value);
+                if (this._renderMode !== value) {
+                    var lastRenderMode = this._renderMode;
+                    this._renderMode = value;
+                    var renderModeMacro = null;
+                    var shaderData = this.shaderData;
+                    switch(value){
+                        case exports.ParticleRenderMode.Billboard:
+                            renderModeMacro = ParticleRenderer._billboardModeMacro;
+                            break;
+                        case exports.ParticleRenderMode.StretchBillboard:
+                            renderModeMacro = ParticleRenderer._stretchedBillboardModeMacro;
+                            break;
+                        case exports.ParticleRenderMode.HorizontalBillboard:
+                            throw "Not implemented";
+                        case exports.ParticleRenderMode.VerticalBillboard:
+                            throw "Not implemented";
+                        case exports.ParticleRenderMode.Mesh:
+                            throw "Not implemented";
+                    }
+                    if (this._currentRenderModeMacro !== renderModeMacro) {
+                        this._currentRenderModeMacro && shaderData.disableMacro(this._currentRenderModeMacro);
+                        renderModeMacro && shaderData.enableMacro(renderModeMacro);
+                        this._currentRenderModeMacro = renderModeMacro;
+                    }
+                    // @ts-ignore
+                    if (lastRenderMode !== exports.ParticleRenderMode.Mesh !== (value === exports.ParticleRenderMode.Mesh)) {
+                        this.generator._reorganizeGeometryBuffers();
+                    }
                 }
             }
         },
         {
-            key: "baseTexture",
+            key: "mesh",
             get: /**
-   * Base texture.
+   * The mesh of particle.
+   * @remarks Valid when `renderMode` is `Mesh`.
    */ function get() {
-                return this.shaderData.getTexture(BaseMaterial._baseTextureProp);
+                return this._mesh;
             },
             set: function set(value) {
-                this.shaderData.setTexture(BaseMaterial._baseTextureProp, value);
-                if (value) {
-                    this.shaderData.enableMacro(BaseMaterial._baseTextureMacro);
-                } else {
-                    this.shaderData.disableMacro(BaseMaterial._baseTextureMacro);
+                var lastMesh = this._mesh;
+                if (lastMesh !== value) {
+                    var _lastMesh, _value;
+                    this._mesh = value;
+                    (_lastMesh = lastMesh) == null ? void 0 : _lastMesh._addReferCount(-1);
+                    (_value = value) == null ? void 0 : _value._addReferCount(1);
+                    if (this.renderMode === exports.ParticleRenderMode.Mesh) {
+                        this.generator._reorganizeGeometryBuffers();
+                    }
                 }
             }
         }
     ]);
-    return ParticleMaterial;
-}(BaseMaterial);
-
-var SubPrimitive = function SubPrimitive() {
-};
+    return ParticleRenderer;
+}(exports.Renderer);
+(function() {
+    ParticleRenderer._billboardModeMacro = ShaderMacro.getByName("RENDERER_MODE_SPHERE_BILLBOARD");
+})();
+(function() {
+    ParticleRenderer._stretchedBillboardModeMacro = ShaderMacro.getByName("RENDERER_MODE_STRETCHED_BILLBOARD");
+})();
+(function() {
+    ParticleRenderer._horizontalBillboardModeMacro = ShaderMacro.getByName("RENDERER_MODE_HORIZONTAL_BILLBOARD");
+})();
+(function() {
+    ParticleRenderer._verticalBillboardModeMacro = ShaderMacro.getByName("RENDERER_MODE_VERTICAL_BILLBOARD");
+})();
+(function() {
+    ParticleRenderer._renderModeMeshMacro = ShaderMacro.getByName("RENDERER_MODE_MESH");
+})();
+(function() {
+    ParticleRenderer._pivotOffsetProperty = ShaderProperty.getByName("renderer_PivotOffset");
+})();
+(function() {
+    ParticleRenderer._lengthScale = ShaderProperty.getByName("renderer_StretchedBillboardLengthScale");
+})();
+(function() {
+    ParticleRenderer._speedScale = ShaderProperty.getByName("renderer_StretchedBillboardSpeedScale");
+})();
+(function() {
+    ParticleRenderer._currentTime = ShaderProperty.getByName("renderer_CurrentTime");
+})();
+__decorate([
+    deepClone
+], ParticleRenderer.prototype, "generator", void 0);
+__decorate([
+    shallowClone
+], ParticleRenderer.prototype, "pivot", void 0);
 
 /**
  * Particle curve mode.
@@ -27051,18 +27250,6 @@ var SubPrimitive = function SubPrimitive() {
     ParticleGradientMode[ParticleGradientMode[/* Random value between two color gradients. */ "TwoGradients"] = 3] = "TwoGradients";
 })(exports.ParticleGradientMode || (exports.ParticleGradientMode = {}));
 
-/**
- * The rendering mode for particle renderer.
- */ exports.ParticleRenderMode = void 0;
-(function(ParticleRenderMode) {
-    ParticleRenderMode[ParticleRenderMode[/** Render particles as billboards facing the active camera. */ "Billboard"] = 0] = "Billboard";
-    ParticleRenderMode[ParticleRenderMode[/** Stretch particles in the direction of motion. */ "StretchBillboard"] = 1] = "StretchBillboard";
-    ParticleRenderMode[ParticleRenderMode[/** Render particles as billboards always facing up along the y-Axis. */ "HorizontalBillboard"] = 2] = "HorizontalBillboard";
-    ParticleRenderMode[ParticleRenderMode[/** Render particles as billboards always facing the player, but not pitching along the x-Axis. */ "VerticalBillboard"] = 3] = "VerticalBillboard";
-    ParticleRenderMode[ParticleRenderMode[/** Render particles as meshes. */ "Mesh"] = 4] = "Mesh";
-    ParticleRenderMode[ParticleRenderMode[/** Do not render particles. */ "None"] = 5] = "None";
-})(exports.ParticleRenderMode || (exports.ParticleRenderMode = {}));
-
 /**
  * The space to simulate particles in.
  */ exports.ParticleSimulationSpace = void 0;
@@ -27071,12 +27258,6 @@ var SubPrimitive = function SubPrimitive() {
     ParticleSimulationSpace[ParticleSimulationSpace[/** Simulate particles in world space. */ "World"] = 1] = "World";
 })(exports.ParticleSimulationSpace || (exports.ParticleSimulationSpace = {}));
 
-exports.ParticleStopMode = void 0;
-(function(ParticleStopMode) {
-    ParticleStopMode[ParticleStopMode[/** Stop emitting new particles and clear existing particles immediately. */ "StopEmittingAndClear"] = 0] = "StopEmittingAndClear";
-    ParticleStopMode[ParticleStopMode[/** Stop emitting new particles, but keep existing particles until they expire. */ "StopEmitting"] = 1] = "StopEmitting";
-})(exports.ParticleStopMode || (exports.ParticleStopMode = {}));
-
 /**
  * @internal
  */ var ParticleRandomSubSeeds;
@@ -29027,181 +29208,60 @@ __decorate([
 ], ParticleGenerator.prototype, "_instanceVertices", void 0);
 
 /**
- * Particle Renderer Component.
- */ var ParticleRenderer = /*#__PURE__*/ function(Renderer1) {
-    _inherits(ParticleRenderer, Renderer1);
-    function ParticleRenderer(entity) {
+ * Particle Material.
+ */ var ParticleMaterial = /*#__PURE__*/ function(BaseMaterial1) {
+    _inherits(ParticleMaterial, BaseMaterial1);
+    function ParticleMaterial(engine) {
         var _this;
-        _this = Renderer1.call(this, entity) || this;
-        /** Particle generator. */ _this.generator = new ParticleGenerator(_assert_this_initialized(_this));
-        /** Specifies how much particles stretch depending on their velocity. */ _this.velocityScale = 0;
-        /** How much are the particles stretched in their direction of motion, defined as the length of the particle compared to its width. */ _this.lengthScale = 2;
-        /** The pivot of particle. */ _this.pivot = new miniprogram.Vector3();
-        _this._currentRenderModeMacro = ParticleRenderer._billboardModeMacro;
-        _this.shaderData.enableMacro(ParticleRenderer._billboardModeMacro);
-        _this._supportInstancedArrays = _this.engine._hardwareRenderer.canIUse(exports.GLCapabilityType.instancedArrays);
+        _this = BaseMaterial1.call(this, engine, Shader.find("particle-shader")) || this;
+        var shaderData = _this.shaderData;
+        shaderData.enableMacro("MATERIAL_OMIT_NORMAL");
+        shaderData.setColor(BaseMaterial._baseColorProp, new miniprogram.Color(1, 1, 1, 1));
+        _this.isTransparent = true;
         return _this;
     }
-    var _proto = ParticleRenderer.prototype;
-    /**
-   * @internal
-   */ _proto._onEnable = function _onEnable() {
-        if (this.generator.main.playOnEnabled) {
-            this.generator.play(false);
-        }
-    };
-    /**
-   * @internal
-   */ _proto._onDisable = function _onDisable() {
-        this.generator.stop(false, exports.ParticleStopMode.StopEmittingAndClear);
-    };
-    /**
-   * @internal
-   */ _proto._prepareRender = function _prepareRender(context) {
-        if (!this._supportInstancedArrays) {
-            return;
-        }
-        var generator = this.generator;
-        generator._update(this.engine.time.deltaTime);
-        // No particles to render
-        if (generator._firstActiveElement === generator._firstFreeElement) {
-            return;
-        }
-        Renderer1.prototype._prepareRender.call(this, context);
-    };
-    /**
-   * @internal
-   */ _proto._updateBounds = function _updateBounds(worldBounds) {
-        worldBounds.min.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
-        worldBounds.max.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
-    };
+    var _proto = ParticleMaterial.prototype;
     /**
-   * @internal
-   */ _proto._updateShaderData = function _updateShaderData(context) {
-        var shaderData = this.shaderData;
-        shaderData.setFloat(ParticleRenderer._lengthScale, this.lengthScale);
-        shaderData.setFloat(ParticleRenderer._speedScale, this.velocityScale);
-        shaderData.setFloat(ParticleRenderer._currentTime, this.generator._playTime);
-        shaderData.setVector3(ParticleRenderer._pivotOffsetProperty, this.pivot);
-        this.generator._updateShaderData(shaderData);
-    };
-    _proto._render = function _render(context) {
-        var generator = this.generator;
-        var primitive = generator._primitive;
-        if (generator._firstActiveElement < generator._firstFreeElement) {
-            primitive.instanceCount = generator._firstFreeElement - generator._firstActiveElement;
-        } else {
-            var instanceCount = generator._currentParticleCount - generator._firstActiveElement;
-            if (generator._firstFreeElement > 0) {
-                instanceCount += generator._firstFreeElement;
-            }
-            primitive.instanceCount = instanceCount;
-        }
-        var material = this.getMaterial();
-        var renderData = this._engine._renderDataPool.getFromPool();
-        renderData.setX(this, material, generator._primitive, generator._subPrimitive);
-        context.camera._renderPipeline.pushRenderData(context, renderData);
-    };
-    _proto._onDestroy = function _onDestroy() {
-        this.generator._destroy();
+   * @inheritdoc
+   */ _proto.clone = function clone() {
+        var dest = new ParticleMaterial(this._engine);
+        this.cloneTo(dest);
+        return dest;
     };
-    _create_class(ParticleRenderer, [
+    _create_class(ParticleMaterial, [
         {
-            key: "renderMode",
+            key: "baseColor",
             get: /**
-   * Specifies how particles are rendered.
+   * Base color.
    */ function get() {
-                return this._renderMode;
+                return this.shaderData.getColor(BaseMaterial._baseColorProp);
             },
             set: function set(value) {
-                if (this._renderMode !== value) {
-                    var lastRenderMode = this._renderMode;
-                    this._renderMode = value;
-                    var renderModeMacro = null;
-                    var shaderData = this.shaderData;
-                    switch(value){
-                        case exports.ParticleRenderMode.Billboard:
-                            renderModeMacro = ParticleRenderer._billboardModeMacro;
-                            break;
-                        case exports.ParticleRenderMode.StretchBillboard:
-                            renderModeMacro = ParticleRenderer._stretchedBillboardModeMacro;
-                            break;
-                        case exports.ParticleRenderMode.HorizontalBillboard:
-                            throw "Not implemented";
-                        case exports.ParticleRenderMode.VerticalBillboard:
-                            throw "Not implemented";
-                        case exports.ParticleRenderMode.Mesh:
-                            throw "Not implemented";
-                    }
-                    if (this._currentRenderModeMacro !== renderModeMacro) {
-                        this._currentRenderModeMacro && shaderData.disableMacro(this._currentRenderModeMacro);
-                        renderModeMacro && shaderData.enableMacro(renderModeMacro);
-                        this._currentRenderModeMacro = renderModeMacro;
-                    }
-                    // @ts-ignore
-                    if (lastRenderMode !== exports.ParticleRenderMode.Mesh !== (value === exports.ParticleRenderMode.Mesh)) {
-                        this.generator._reorganizeGeometryBuffers();
-                    }
+                var baseColor = this.shaderData.getColor(BaseMaterial._baseColorProp);
+                if (value !== baseColor) {
+                    baseColor.copyFrom(value);
                 }
             }
         },
         {
-            key: "mesh",
+            key: "baseTexture",
             get: /**
-   * The mesh of particle.
-   * @remarks Valid when `renderMode` is `Mesh`.
+   * Base texture.
    */ function get() {
-                return this._mesh;
+                return this.shaderData.getTexture(BaseMaterial._baseTextureProp);
             },
             set: function set(value) {
-                var lastMesh = this._mesh;
-                if (lastMesh !== value) {
-                    var _lastMesh, _value;
-                    this._mesh = value;
-                    (_lastMesh = lastMesh) == null ? void 0 : _lastMesh._addReferCount(-1);
-                    (_value = value) == null ? void 0 : _value._addReferCount(1);
-                    if (this.renderMode === exports.ParticleRenderMode.Mesh) {
-                        this.generator._reorganizeGeometryBuffers();
-                    }
+                this.shaderData.setTexture(BaseMaterial._baseTextureProp, value);
+                if (value) {
+                    this.shaderData.enableMacro(BaseMaterial._baseTextureMacro);
+                } else {
+                    this.shaderData.disableMacro(BaseMaterial._baseTextureMacro);
                 }
             }
         }
     ]);
-    return ParticleRenderer;
-}(exports.Renderer);
-(function() {
-    ParticleRenderer._billboardModeMacro = ShaderMacro.getByName("RENDERER_MODE_SPHERE_BILLBOARD");
-})();
-(function() {
-    ParticleRenderer._stretchedBillboardModeMacro = ShaderMacro.getByName("RENDERER_MODE_STRETCHED_BILLBOARD");
-})();
-(function() {
-    ParticleRenderer._horizontalBillboardModeMacro = ShaderMacro.getByName("RENDERER_MODE_HORIZONTAL_BILLBOARD");
-})();
-(function() {
-    ParticleRenderer._verticalBillboardModeMacro = ShaderMacro.getByName("RENDERER_MODE_VERTICAL_BILLBOARD");
-})();
-(function() {
-    ParticleRenderer._renderModeMeshMacro = ShaderMacro.getByName("RENDERER_MODE_MESH");
-})();
-(function() {
-    ParticleRenderer._pivotOffsetProperty = ShaderProperty.getByName("renderer_PivotOffset");
-})();
-(function() {
-    ParticleRenderer._lengthScale = ShaderProperty.getByName("renderer_StretchedBillboardLengthScale");
-})();
-(function() {
-    ParticleRenderer._speedScale = ShaderProperty.getByName("renderer_StretchedBillboardSpeedScale");
-})();
-(function() {
-    ParticleRenderer._currentTime = ShaderProperty.getByName("renderer_CurrentTime");
-})();
-__decorate([
-    deepClone
-], ParticleRenderer.prototype, "generator", void 0);
-__decorate([
-    shallowClone
-], ParticleRenderer.prototype, "pivot", void 0);
+    return ParticleMaterial;
+}(BaseMaterial);
 
 /**
  * A burst is a particle emission event, where a number of particles are all emitted at the same time
@@ -29907,6 +29967,7 @@ exports.PBRMaterial = PBRMaterial;
 exports.PBRSpecularMaterial = PBRSpecularMaterial;
 exports.ParticleCompositeCurve = ParticleCompositeCurve;
 exports.ParticleCurve = ParticleCurve;
+exports.ParticleGenerator = ParticleGenerator;
 exports.ParticleMaterial = ParticleMaterial;
 exports.ParticleRenderer = ParticleRenderer;
 exports.PhysicsMaterial = PhysicsMaterial;