@galacean/effects-core 2.1.0-alpha.11 → 2.1.0-alpha.13

package/dist/index.js

@@ -3,7 +3,7 @@
  * Description: Galacean Effects runtime core for the web
  * Author: Ant Group CO., Ltd.
  * Contributors: 燃然,飂兮,十弦,云垣,茂安,意绮
- * Version: v2.1.0-alpha.11
+ * Version: v2.1.0-alpha.13
  */
 
 'use strict';
@@ -6945,6 +6945,28 @@ exports.MaterialRenderType = void 0;
                 this.shaderDirty = true;
             }
         },
+        {
+            key: "mainTexture",
+            get: /**
+   * 材质的主纹理
+   */ function get() {
+                return this.getTexture("_MainTex");
+            },
+            set: function set(value) {
+                this.setTexture("_MainTex", value);
+            }
+        },
+        {
+            key: "color",
+            get: /**
+   * 材质的主颜色
+   */ function get() {
+                return this.getColor("_Color");
+            },
+            set: function set(value) {
+                this.setColor("_Color", value);
+            }
+        },
         {
             key: "blending",
             set: /******** effects-core 中会调用 引擎必须实现 ***********************/ /**
@@ -10081,7 +10103,7 @@ var integrate = "float calculateMovement(float t,vec2 p1,vec2 p2,vec2 p3,vec2 p4
 
 var itemVert = "precision highp float;attribute vec2 atlasOffset;attribute vec3 aPos;varying vec2 vTexCoord;varying vec3 vParams;varying vec4 vColor;uniform vec2 _Size;uniform vec4 _Color;uniform vec4 _TexParams;uniform vec4 _TexOffset;uniform mat4 effects_MatrixVP;uniform mat4 effects_MatrixInvV;uniform mat4 effects_ObjectToWorld;\n#ifdef ENV_EDITOR\nuniform vec4 uEditorTransform;\n#endif\nvoid main(){vec4 texParams=_TexParams;vTexCoord=vec2(atlasOffset.xy*_TexOffset.zw+_TexOffset.xy);vColor=_Color;vParams=vec3(0.0,texParams.y,texParams.x);vec4 pos=vec4(aPos.xy*_Size,aPos.z,1.0);gl_Position=effects_MatrixVP*effects_ObjectToWorld*pos;\n#ifdef ENV_EDITOR\ngl_Position=vec4(gl_Position.xy*uEditorTransform.xy+uEditorTransform.zw*gl_Position.w,gl_Position.zw);\n#endif\n}";
 
-var itemFrag = "precision highp float;varying vec4 vColor;varying vec2 vTexCoord;varying vec3 vParams;uniform sampler2D uSampler0;vec4 blendColor(vec4 color,vec4 vc,float mode){vec4 ret=color*vc;float alpha=ret.a;if(mode==1.){ret.rgb*=alpha;}else if(mode==2.){ret.rgb*=alpha;ret.a=dot(ret.rgb,vec3(0.33333333));}else if(mode==3.){alpha=color.r*alpha;ret=vec4(vc.rgb*alpha,alpha);}return ret;}void main(){vec4 color=vec4(0.);vec4 texColor=texture2D(uSampler0,vTexCoord.xy);color=blendColor(texColor,vColor,floor(0.5+vParams.y));if(vParams.z==0.&&color.a<0.04){discard;}color.a=clamp(color.a,0.0,1.0);gl_FragColor=color;}";
+var itemFrag = "precision highp float;varying vec4 vColor;varying vec2 vTexCoord;varying vec3 vParams;uniform sampler2D _MainTex;vec4 blendColor(vec4 color,vec4 vc,float mode){vec4 ret=color*vc;float alpha=ret.a;if(mode==1.){ret.rgb*=alpha;}else if(mode==2.){ret.rgb*=alpha;ret.a=dot(ret.rgb,vec3(0.33333333));}else if(mode==3.){alpha=color.r*alpha;ret=vec4(vc.rgb*alpha,alpha);}return ret;}void main(){vec4 color=vec4(0.);vec4 texColor=texture2D(_MainTex,vTexCoord.xy);color=blendColor(texColor,vColor,floor(0.5+vParams.y));if(vParams.z==0.&&color.a<0.04){discard;}color.a=clamp(color.a,0.0,1.0);gl_FragColor=color;}";
 
 var particleFrag = "#version 100\nprecision mediump float;vec4 blendColor(vec4 color,vec4 vc,float mode){vec4 ret=color*vc;float alpha=ret.a;if(mode==1.){ret.rgb*=alpha;}else if(mode==2.){ret.rgb*=alpha;ret.a=dot(ret.rgb,vec3(0.33333333));}else if(mode==3.){alpha=color.r*alpha;ret=vec4(vc.rgb*alpha,alpha);}return ret;}\n#define PATICLE_SHADER 1\nvarying float vLife;varying vec2 vTexCoord;varying vec4 vColor;uniform vec3 emissionColor;uniform float emissionIntensity;uniform sampler2D uMaskTex;uniform vec4 uColorParams;uniform vec2 uTexOffset;\n#ifdef COLOR_OVER_LIFETIME\nuniform sampler2D uColorOverLifetime;\n#endif\n#ifdef USE_SPRITE\nvarying vec4 vTexCoordBlend;\n#endif\nvarying float vSeed;\n#ifdef PREVIEW_BORDER\nuniform vec4 uPreviewColor;\n#endif\n#ifdef USE_SPRITE\nvec4 getTextureColor(sampler2D tex,vec2 texCoord){if(vTexCoordBlend.w>0.){return mix(texture2D(tex,texCoord),texture2D(tex,vTexCoordBlend.xy+texCoord),vTexCoordBlend.z);}return texture2D(tex,texCoord);}\n#else\n#define getTextureColor texture2D\n#endif\n#ifndef WEBGL2\n#define round(a) floor(0.5+a)\n#endif\n#ifdef PREVIEW_BORDER\nvoid main(){gl_FragColor=uPreviewColor;}\n#else\nvoid main(){vec4 color=vec4(1.0);vec4 tempColor=vColor;vec2 texOffset=uTexOffset;if(vLife<0.){discard;}if(uColorParams.x>0.0){color=getTextureColor(uMaskTex,vTexCoord);}\n#ifdef COLOR_OVER_LIFETIME\n#ifndef ENABLE_VERTEX_TEXTURE\ntempColor*=texture2D(uColorOverLifetime,vec2(vLife,0.));\n#endif\n#endif\ncolor=blendColor(color,tempColor,round(uColorParams.y));if(color.a<=0.01&&uColorParams.w>0.){float _at=texture2D(uMaskTex,vTexCoord+texOffset).a+texture2D(uMaskTex,vTexCoord+texOffset*-1.).a;if(_at<=0.02){discard;}}vec3 emission=emissionColor*pow(2.0,emissionIntensity);color=vec4(pow(pow(color.rgb,vec3(2.2))+emission,vec3(1.0/2.2)),color.a);gl_FragColor=color;}\n#endif\n";
 
@@ -10610,6 +10632,9 @@ var seed$5 = 1;
         this.renderer = renderer;
         if (postProcessingEnabled) {
             var enableHDR = true;
+            if (!this.renderer.engine.gpuCapability.detail.halfFloatTexture) {
+                throw new Error("Half float texture is not supported.");
+            }
             // 使用HDR浮点纹理，FLOAT在IOS上报错，使用HALF_FLOAT
             var textureType = enableHDR ? glContext.HALF_FLOAT : glContext.UNSIGNED_BYTE;
             attachments = [
@@ -11330,7 +11355,7 @@ var FinalCopyRP = /*#__PURE__*/ function(RenderPass) {
 var GlobalUniforms = function GlobalUniforms() {
     this.floats = {};
     this.ints = {};
-    // vector3s: Record<string, vec3> = {};
+    this.vector3s = {};
     this.vector4s = {};
     this.matrices = {};
     //...
@@ -11571,6 +11596,9 @@ var Renderer = /*#__PURE__*/ function() {
     _proto.setGlobalVector4 = function setGlobalVector4(name, value) {
     // OVERRIDE
     };
+    _proto.setGlobalVector3 = function setGlobalVector3(name, value) {
+    // OVERRIDE
+    };
     _proto.setGlobalMatrix = function setGlobalMatrix(name, value) {
     // OVERRIDE
     };
@@ -13236,10 +13264,10 @@ var Vector4Curve = /*#__PURE__*/ function(ValueGetter) {
     }
     var _proto = Vector4Curve.prototype;
     _proto.onCreate = function onCreate(arg) {
-        this.xCurve = createValueGetter(arg.x);
-        this.yCurve = createValueGetter(arg.y);
-        this.zCurve = createValueGetter(arg.z);
-        this.wCurve = createValueGetter(arg.w);
+        this.xCurve = createValueGetter(arg[0]);
+        this.yCurve = createValueGetter(arg[1]);
+        this.zCurve = createValueGetter(arg[2]);
+        this.wCurve = createValueGetter(arg[3]);
     };
     _proto.getValue = function getValue(t) {
         var x = this.xCurve.getValue(t);
@@ -13339,10 +13367,10 @@ var ColorCurve = /*#__PURE__*/ function(ValueGetter) {
     }
     var _proto = ColorCurve.prototype;
     _proto.onCreate = function onCreate(arg) {
-        this.rCurve = createValueGetter(arg.r);
-        this.gCurve = createValueGetter(arg.g);
-        this.bCurve = createValueGetter(arg.b);
-        this.aCurve = createValueGetter(arg.a);
+        this.rCurve = createValueGetter(arg[0]);
+        this.gCurve = createValueGetter(arg[1]);
+        this.bCurve = createValueGetter(arg[2]);
+        this.aCurve = createValueGetter(arg[3]);
     };
     _proto.getValue = function getValue(t) {
         var r = this.rCurve.getValue(t);
@@ -13444,7 +13472,7 @@ var ColorCurve = /*#__PURE__*/ function(ValueGetter) {
    * @param texture - 纹理对象
    */ _proto.setTexture = function setTexture(texture) {
         this.renderer.texture = texture;
-        this.material.setTexture("uSampler0", texture);
+        this.material.setTexture("_MainTex", texture);
     };
     /**
    * @internal
@@ -13523,15 +13551,7 @@ var ColorCurve = /*#__PURE__*/ function(ValueGetter) {
         geometry.setIndexData(indexData);
         geometry.setAttributeData("atlasOffset", attributes.atlasOffset);
         geometry.setDrawCount(data.index.length);
-        for(var i = 0; i < textures.length; i++){
-            var texture1 = textures[i];
-            material.setTexture("uSampler" + i, texture1);
-        }
-        // FIXME: 内存泄漏的临时方案，后面再调整
-        var emptyTexture = this.emptyTexture;
-        for(var k = textures.length; k < exports.maxSpriteMeshItemCount; k++){
-            material.setTexture("uSampler" + k, emptyTexture);
-        }
+        material.setTexture("_MainTex", texture);
     };
     _proto.getItemGeometryData = function getItemGeometryData() {
         var renderer = this.renderer;
@@ -13649,7 +13669,7 @@ var ColorCurve = /*#__PURE__*/ function(ValueGetter) {
         setBlendMode(material, states.blendMode);
         setMaskMode(material, states.maskMode);
         setSideMode(material, states.side);
-        material.shader.shaderData.properties = 'uSampler0("uSampler0",2D) = "white" {}';
+        material.shader.shaderData.properties = '_MainTex("_MainTex",2D) = "white" {}';
         if (!material.hasUniform("_Color")) {
             material.setVector4("_Color", new Vector4(0, 0, 0, 1));
         }
@@ -15387,6 +15407,329 @@ var PolyStar = /*#__PURE__*/ function(ShapePrimitive) {
     return PolyStar;
 }(ShapePrimitive);
 
+// const tempPoints = [new Point(), new Point(), new Point(), new Point()];
+/**
+ * The `Rectangle` object is an area defined by its position, as indicated by its upper-left corner
+ * point (`x`, `y`) and by its `width` and its `height`.
+ */ var Rectangle$1 = /*#__PURE__*/ function(ShapePrimitive) {
+    _inherits(Rectangle, ShapePrimitive);
+    function Rectangle(x, y, width, height) {
+        if (x === void 0) x = 0;
+        if (y === void 0) y = 0;
+        if (width === void 0) width = 0;
+        if (height === void 0) height = 0;
+        var _this;
+        _this = ShapePrimitive.call(this) || this;
+        _this.x = Number(x);
+        _this.y = Number(y);
+        _this.width = Number(width);
+        _this.height = Number(height);
+        return _this;
+    }
+    var _proto = Rectangle.prototype;
+    /** Determines whether the Rectangle is empty. */ _proto.isEmpty = function isEmpty() {
+        return this.left === this.right || this.top === this.bottom;
+    };
+    /**
+   * Creates a clone of this Rectangle
+   * @returns a copy of the rectangle
+   */ _proto.clone = function clone() {
+        return new Rectangle(this.x, this.y, this.width, this.height);
+    };
+    /**
+   * Converts a Bounds object to a Rectangle object.
+   * @param bounds - The bounds to copy and convert to a rectangle.
+   * @returns Returns itself.
+   */ //   copyFromBounds (bounds: Bounds): this {
+    //     this.x = bounds.minX;
+    //     this.y = bounds.minY;
+    //     this.width = bounds.maxX - bounds.minX;
+    //     this.height = bounds.maxY - bounds.minY;
+    //     return this;
+    //   }
+    /**
+   * Copies another rectangle to this one.
+   * @param rectangle - The rectangle to copy from.
+   * @returns Returns itself.
+   */ _proto.copyFrom = function copyFrom(rectangle) {
+        this.x = rectangle.x;
+        this.y = rectangle.y;
+        this.width = rectangle.width;
+        this.height = rectangle.height;
+        return this;
+    };
+    /**
+   * Copies this rectangle to another one.
+   * @param rectangle - The rectangle to copy to.
+   * @returns Returns given parameter.
+   */ _proto.copyTo = function copyTo(rectangle) {
+        rectangle.copyFrom(this);
+        return rectangle;
+    };
+    /**
+   * Checks whether the x and y coordinates given are contained within this Rectangle
+   * @param x - The X coordinate of the point to test
+   * @param y - The Y coordinate of the point to test
+   * @returns Whether the x/y coordinates are within this Rectangle
+   */ _proto.contains = function contains(x, y) {
+        if (this.width <= 0 || this.height <= 0) {
+            return false;
+        }
+        if (x >= this.x && x < this.x + this.width) {
+            if (y >= this.y && y < this.y + this.height) {
+                return true;
+            }
+        }
+        return false;
+    };
+    /**
+   * Checks whether the x and y coordinates given are contained within this rectangle including the stroke.
+   * @param x - The X coordinate of the point to test
+   * @param y - The Y coordinate of the point to test
+   * @param strokeWidth - The width of the line to check
+   * @returns Whether the x/y coordinates are within this rectangle
+   */ _proto.strokeContains = function strokeContains(x, y, strokeWidth) {
+        var _this = this, width = _this.width, height = _this.height;
+        if (width <= 0 || height <= 0) {
+            return false;
+        }
+        var _x = this.x;
+        var _y = this.y;
+        var outerLeft = _x - strokeWidth / 2;
+        var outerRight = _x + width + strokeWidth / 2;
+        var outerTop = _y - strokeWidth / 2;
+        var outerBottom = _y + height + strokeWidth / 2;
+        var innerLeft = _x + strokeWidth / 2;
+        var innerRight = _x + width - strokeWidth / 2;
+        var innerTop = _y + strokeWidth / 2;
+        var innerBottom = _y + height - strokeWidth / 2;
+        return x >= outerLeft && x <= outerRight && y >= outerTop && y <= outerBottom && !(x > innerLeft && x < innerRight && y > innerTop && y < innerBottom);
+    };
+    /**
+   * Determines whether the `other` Rectangle transformed by `transform` intersects with `this` Rectangle object.
+   * Returns true only if the area of the intersection is >0, this means that Rectangles
+   * sharing a side are not overlapping. Another side effect is that an arealess rectangle
+   * (width or height equal to zero) can't intersect any other rectangle.
+   * @param {Rectangle} other - The Rectangle to intersect with `this`.
+   * @param {Matrix} transform - The transformation matrix of `other`.
+   * @returns {boolean} A value of `true` if the transformed `other` Rectangle intersects with `this`; otherwise `false`.
+   */ //   intersects (other: Rectangle, transform?: Matrix4): boolean {
+    //     if (!transform) {
+    //       const x0 = this.x < other.x ? other.x : this.x;
+    //       const x1 = this.right > other.right ? other.right : this.right;
+    //       if (x1 <= x0) {
+    //         return false;
+    //       }
+    //       const y0 = this.y < other.y ? other.y : this.y;
+    //       const y1 = this.bottom > other.bottom ? other.bottom : this.bottom;
+    //       return y1 > y0;
+    //     }
+    //     const x0 = this.left;
+    //     const x1 = this.right;
+    //     const y0 = this.top;
+    //     const y1 = this.bottom;
+    //     if (x1 <= x0 || y1 <= y0) {
+    //       return false;
+    //     }
+    //     const lt = tempPoints[0].set(other.left, other.top);
+    //     const lb = tempPoints[1].set(other.left, other.bottom);
+    //     const rt = tempPoints[2].set(other.right, other.top);
+    //     const rb = tempPoints[3].set(other.right, other.bottom);
+    //     if (rt.x <= lt.x || lb.y <= lt.y) {
+    //       return false;
+    //     }
+    //     const s = Math.sign((transform.a * transform.d) - (transform.b * transform.c));
+    //     if (s === 0) {
+    //       return false;
+    //     }
+    //     transform.apply(lt, lt);
+    //     transform.apply(lb, lb);
+    //     transform.apply(rt, rt);
+    //     transform.apply(rb, rb);
+    //     if (Math.max(lt.x, lb.x, rt.x, rb.x) <= x0
+    //             || Math.min(lt.x, lb.x, rt.x, rb.x) >= x1
+    //             || Math.max(lt.y, lb.y, rt.y, rb.y) <= y0
+    //             || Math.min(lt.y, lb.y, rt.y, rb.y) >= y1) {
+    //       return false;
+    //     }
+    //     const nx = s * (lb.y - lt.y);
+    //     const ny = s * (lt.x - lb.x);
+    //     const n00 = (nx * x0) + (ny * y0);
+    //     const n10 = (nx * x1) + (ny * y0);
+    //     const n01 = (nx * x0) + (ny * y1);
+    //     const n11 = (nx * x1) + (ny * y1);
+    //     if (Math.max(n00, n10, n01, n11) <= (nx * lt.x) + (ny * lt.y)
+    //             || Math.min(n00, n10, n01, n11) >= (nx * rb.x) + (ny * rb.y)) {
+    //       return false;
+    //     }
+    //     const mx = s * (lt.y - rt.y);
+    //     const my = s * (rt.x - lt.x);
+    //     const m00 = (mx * x0) + (my * y0);
+    //     const m10 = (mx * x1) + (my * y0);
+    //     const m01 = (mx * x0) + (my * y1);
+    //     const m11 = (mx * x1) + (my * y1);
+    //     if (Math.max(m00, m10, m01, m11) <= (mx * lt.x) + (my * lt.y)
+    //             || Math.min(m00, m10, m01, m11) >= (mx * rb.x) + (my * rb.y)) {
+    //       return false;
+    //     }
+    //     return true;
+    //   }
+    /**
+   * Pads the rectangle making it grow in all directions.
+   * If paddingY is omitted, both paddingX and paddingY will be set to paddingX.
+   * @param paddingX - The horizontal padding amount.
+   * @param paddingY - The vertical padding amount.
+   * @returns Returns itself.
+   */ _proto.pad = function pad(paddingX, paddingY) {
+        if (paddingX === void 0) paddingX = 0;
+        if (paddingY === void 0) paddingY = paddingX;
+        this.x -= paddingX;
+        this.y -= paddingY;
+        this.width += paddingX * 2;
+        this.height += paddingY * 2;
+        return this;
+    };
+    /**
+   * Fits this rectangle around the passed one.
+   * @param rectangle - The rectangle to fit.
+   * @returns Returns itself.
+   */ _proto.fit = function fit(rectangle) {
+        var x1 = Math.max(this.x, rectangle.x);
+        var x2 = Math.min(this.x + this.width, rectangle.x + rectangle.width);
+        var y1 = Math.max(this.y, rectangle.y);
+        var y2 = Math.min(this.y + this.height, rectangle.y + rectangle.height);
+        this.x = x1;
+        this.width = Math.max(x2 - x1, 0);
+        this.y = y1;
+        this.height = Math.max(y2 - y1, 0);
+        return this;
+    };
+    /**
+   * Enlarges rectangle that way its corners lie on grid
+   * @param resolution - resolution
+   * @param eps - precision
+   * @returns Returns itself.
+   */ _proto.ceil = function ceil(resolution, eps) {
+        if (resolution === void 0) resolution = 1;
+        if (eps === void 0) eps = 0.001;
+        var x2 = Math.ceil((this.x + this.width - eps) * resolution) / resolution;
+        var y2 = Math.ceil((this.y + this.height - eps) * resolution) / resolution;
+        this.x = Math.floor((this.x + eps) * resolution) / resolution;
+        this.y = Math.floor((this.y + eps) * resolution) / resolution;
+        this.width = x2 - this.x;
+        this.height = y2 - this.y;
+        return this;
+    };
+    /**
+   * Enlarges this rectangle to include the passed rectangle.
+   * @param rectangle - The rectangle to include.
+   * @returns Returns itself.
+   */ _proto.enlarge = function enlarge(rectangle) {
+        var x1 = Math.min(this.x, rectangle.x);
+        var x2 = Math.max(this.x + this.width, rectangle.x + rectangle.width);
+        var y1 = Math.min(this.y, rectangle.y);
+        var y2 = Math.max(this.y + this.height, rectangle.y + rectangle.height);
+        this.x = x1;
+        this.width = x2 - x1;
+        this.y = y1;
+        this.height = y2 - y1;
+        return this;
+    };
+    /**
+   * Returns the framing rectangle of the rectangle as a Rectangle object
+   * @param out - optional rectangle to store the result
+   * @returns The framing rectangle
+   */ _proto.getBounds = function getBounds(out) {
+        out = out || new Rectangle();
+        out.copyFrom(this);
+        return out;
+    };
+    _proto.getX = function getX() {
+        return this.x;
+    };
+    _proto.getY = function getY() {
+        return this.y;
+    };
+    _proto.build = function build(points) {
+        var x = this.x;
+        var y = this.y;
+        var width = this.width;
+        var height = this.height;
+        if (!(width >= 0 && height >= 0)) {
+            return points;
+        }
+        points[0] = x;
+        points[1] = y;
+        points[2] = x + width;
+        points[3] = y;
+        points[4] = x + width;
+        points[5] = y + height;
+        points[6] = x;
+        points[7] = y + height;
+        return points;
+    };
+    _proto.triangulate = function triangulate(points, vertices, verticesOffset, indices, indicesOffset) {
+        var count = 0;
+        var verticesStride = 2;
+        verticesOffset *= verticesStride;
+        vertices[verticesOffset + count] = points[0];
+        vertices[verticesOffset + count + 1] = points[1];
+        count += verticesStride;
+        vertices[verticesOffset + count] = points[2];
+        vertices[verticesOffset + count + 1] = points[3];
+        count += verticesStride;
+        vertices[verticesOffset + count] = points[6];
+        vertices[verticesOffset + count + 1] = points[7];
+        count += verticesStride;
+        vertices[verticesOffset + count] = points[4];
+        vertices[verticesOffset + count + 1] = points[5];
+        count += verticesStride;
+        var verticesIndex = verticesOffset / verticesStride;
+        // triangle 1
+        indices[indicesOffset++] = verticesIndex;
+        indices[indicesOffset++] = verticesIndex + 1;
+        indices[indicesOffset++] = verticesIndex + 2;
+        // triangle 2
+        indices[indicesOffset++] = verticesIndex + 1;
+        indices[indicesOffset++] = verticesIndex + 3;
+        indices[indicesOffset++] = verticesIndex + 2;
+    };
+    _create_class(Rectangle, [
+        {
+            key: "left",
+            get: /** Returns the left edge of the rectangle. */ function get() {
+                return this.x;
+            }
+        },
+        {
+            key: "right",
+            get: /** Returns the right edge of the rectangle. */ function get() {
+                return this.x + this.width;
+            }
+        },
+        {
+            key: "top",
+            get: /** Returns the top edge of the rectangle. */ function get() {
+                return this.y;
+            }
+        },
+        {
+            key: "bottom",
+            get: /** Returns the bottom edge of the rectangle. */ function get() {
+                return this.y + this.height;
+            }
+        }
+    ], [
+        {
+            key: "EMPTY",
+            get: /** A constant empty rectangle. This is a new object every time the property is accessed */ function get() {
+                return new Rectangle(0, 0, 0, 0);
+            }
+        }
+    ]);
+    return Rectangle;
+}(ShapePrimitive);
+
 var ShapePath = /*#__PURE__*/ function() {
     function ShapePath(graphicsPath) {
         this.graphicsPath = graphicsPath;
@@ -15423,6 +15766,11 @@ var ShapePath = /*#__PURE__*/ function() {
                         this.polyStar(data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
                         break;
                     }
+                case "rect":
+                    {
+                        this.rect(data[0], data[1], data[2], data[3], data[4]);
+                        break;
+                    }
             }
         }
         this.endPoly();
@@ -15468,6 +15816,18 @@ var ShapePath = /*#__PURE__*/ function() {
         return this;
     };
     /**
+   * Draws a rectangle shape. This method adds a new rectangle path to the current drawing.
+   * @param x - The x-coordinate of the upper-left corner of the rectangle.
+   * @param y - The y-coordinate of the upper-left corner of the rectangle.
+   * @param w - The width of the rectangle.
+   * @param h - The height of the rectangle.
+   * @param transform - An optional `Matrix` object to apply a transformation to the rectangle.
+   * @returns The instance of the current object for chaining.
+   */ _proto.rect = function rect(x, y, w, h, transform) {
+        this.drawShape(new Rectangle$1(x, y, w, h), transform);
+        return this;
+    };
+    /**
    * Draws a given shape on the canvas.
    * This is a generic method that can draw any type of shape specified by the `ShapePrimitive` parameter.
    * An optional transformation matrix can be applied to the shape, allowing for complex transformations.
@@ -15603,8 +15963,8 @@ var GraphicsPath = /*#__PURE__*/ function() {
     };
     /**
    * Draws a rectangle shape. This method adds a new rectangle path to the current drawing.
-   * @param x - The x-coordinate of the top-left corner of the rectangle.
-   * @param y - The y-coordinate of the top-left corner of the rectangle.
+   * @param x - The x-coordinate of the upper-left corner of the rectangle.
+   * @param y - The y-coordinate of the upper-left corner of the rectangle.
    * @param w - The width of the rectangle.
    * @param h - The height of the rectangle.
    * @param transform - An optional `Matrix` object to apply a transformation to the rectangle.
@@ -15830,7 +16190,7 @@ exports.ShapeComponent = /*#__PURE__*/ function(MeshComponent) {
             case 1:
                 {
                     var rectangleData = shapeData;
-                    this.path.rect(-rectangleData.width / 2, rectangleData.height / 2, rectangleData.width, rectangleData.height);
+                    this.path.rect(-rectangleData.width / 2, -rectangleData.height / 2, rectangleData.width, rectangleData.height);
                     this.setFillColor(rectangleData.fill);
                     break;
                 }
@@ -16392,6 +16752,7 @@ exports.InteractComponent = /*#__PURE__*/ function(RendererComponent) {
                 0
             ]
         };
+        _this.duringPlay = false;
         /** 是否响应点击和拖拽交互事件 */ _this._interactive = true;
         _this.getHitTestParams = function(force) {
             if (!_this.clickable) {
@@ -16456,7 +16817,10 @@ exports.InteractComponent = /*#__PURE__*/ function(RendererComponent) {
     _proto.onDisable = function onDisable() {
         if (this.item && this.item.composition) {
             var _this_previewContent;
-            this.item.composition.removeInteractiveItem(this.item, this.item.props.content.options.type);
+            if (this.duringPlay && !this.item.transform.getValid()) {
+                this.item.composition.removeInteractiveItem(this.item, this.item.props.content.options.type);
+                this.duringPlay = false;
+            }
             this.clickable = false;
             (_this_previewContent = this.previewContent) == null ? void 0 : _this_previewContent.mesh.dispose();
             this.endDragTarget();
@@ -16467,15 +16831,15 @@ exports.InteractComponent = /*#__PURE__*/ function(RendererComponent) {
         if (type === InteractType.CLICK) {
             this.clickable = true;
         }
-        var options = this.item.props.content.options;
-        if (this.item.composition) {
-            this.item.composition.addInteractiveItem(this.item, options.type);
-        }
     };
     _proto.onUpdate = function onUpdate(dt) {
         var _this_previewContent;
-        if (!this.isActiveAndEnabled) {
-            return;
+        this.duringPlay = true;
+        // trigger messageBegin when item enter
+        if (this.item.time > 0 && this.item.time - dt / 1000 <= 0) {
+            var _this_item_composition;
+            var options = this.item.props.content.options;
+            (_this_item_composition = this.item.composition) == null ? void 0 : _this_item_composition.addInteractiveItem(this.item, options.type);
         }
         (_this_previewContent = this.previewContent) == null ? void 0 : _this_previewContent.updateMesh();
         if (!this.dragEvent || !this.bouncingArg) {
@@ -16656,10 +17020,10 @@ function shouldIgnoreBouncing(arg, mul) {
         return this.boundingBoxData;
     };
     _proto.getBoundingBox = function getBoundingBox() {
-        var maxX = 0;
-        var maxY = 0;
-        var minX = 0;
-        var minY = 0;
+        var maxX = -Number.MAX_VALUE;
+        var maxY = -Number.MAX_VALUE;
+        var minX = Number.MAX_VALUE;
+        var minY = Number.MAX_VALUE;
         for(var _iterator = _create_for_of_iterator_helper_loose(this.boundingBoxData.area), _step; !(_step = _iterator()).done;){
             var triangle = _step.value;
             maxX = Math.max(triangle.p0.x, triangle.p1.x, triangle.p2.x, maxX);
@@ -18076,7 +18440,7 @@ exports.VFXItem = /*#__PURE__*/ function(EffectsObject) {
                 options: {}
             };
         }
-        if (duration <= 0) {
+        if (duration < 0) {
             throw new Error("Item duration can't be less than 0, see " + HELP_LINK["Item duration can't be less than 0"] + ".");
         }
         this.rendererComponents.length = 0;
@@ -18437,6 +18801,16 @@ exports.SpriteComponent = /*#__PURE__*/ function(BaseRenderComponent) {
         }
         var life = Math.min(Math.max(time / duration, 0.0), 1.0);
         var ta = this.textureSheetAnimation;
+        var video = this.renderer.texture.source.video;
+        if (video) {
+            if (time === 0) {
+                video.pause();
+            } else {
+                video.play().catch(function(e) {
+                    _this.engine.renderErrors.add(e);
+                });
+            }
+        }
         if (ta) {
             var _this_material_getVector4;
             var total = ta.total || ta.row * ta.col;
@@ -18491,16 +18865,6 @@ exports.SpriteComponent = /*#__PURE__*/ function(BaseRenderComponent) {
                 dy
             ]);
         }
-        var video = this.renderer.texture.source.video;
-        if (video) {
-            if (time === 0 || time === this.item.duration) {
-                video.pause();
-            } else {
-                video.play().catch(function(e) {
-                    _this.engine.renderErrors.add(e);
-                });
-            }
-        }
     };
     _proto.onDestroy = function onDestroy() {
         if (this.item && this.item.composition) {
@@ -23997,6 +24361,51 @@ var Vector4PropertyMixerPlayable = /*#__PURE__*/ function(Playable) {
     return Vector4PropertyMixerPlayable;
 }(Playable);
 
+var ColorPropertyMixerPlayable = /*#__PURE__*/ function(Playable) {
+    _inherits(ColorPropertyMixerPlayable, Playable);
+    function ColorPropertyMixerPlayable() {
+        var _this;
+        _this = Playable.apply(this, arguments) || this;
+        _this.propertyName = "";
+        return _this;
+    }
+    var _proto = ColorPropertyMixerPlayable.prototype;
+    _proto.processFrame = function processFrame(context) {
+        var boundObject = context.output.getUserData();
+        if (!boundObject) {
+            return;
+        }
+        var hasInput = false;
+        var value = boundObject[this.propertyName];
+        if (!_instanceof1(value, Color)) {
+            return;
+        }
+        value.setZero();
+        // evaluate the curve
+        for(var i = 0; i < this.getInputCount(); i++){
+            var weight = this.getInputWeight(i);
+            if (weight > 0) {
+                var propertyClipPlayable = this.getInput(i);
+                if (!_instanceof1(propertyClipPlayable, PropertyClipPlayable)) {
+                    console.error("ColorPropertyMixerPlayable received incompatible input");
+                    continue;
+                }
+                var curveValue = propertyClipPlayable.value;
+                value.r += curveValue.r * weight;
+                value.g += curveValue.g * weight;
+                value.b += curveValue.b * weight;
+                value.a += curveValue.a * weight;
+                hasInput = true;
+            }
+        }
+        // set value
+        if (hasInput) {
+            boundObject[this.propertyName] = value;
+        }
+    };
+    return ColorPropertyMixerPlayable;
+}(Playable);
+
 var PropertyTrack = /*#__PURE__*/ function(TrackAsset) {
     _inherits(PropertyTrack, TrackAsset);
     function PropertyTrack() {
@@ -24156,7 +24565,7 @@ exports.ColorPropertyTrack = /*#__PURE__*/ function(PropertyTrack) {
     }
     var _proto = ColorPropertyTrack.prototype;
     _proto.createTrackMixer = function createTrackMixer(graph) {
-        var mixer = new FloatPropertyMixerPlayable(graph);
+        var mixer = new ColorPropertyMixerPlayable(graph);
         var propertyNames = this.propertyNames;
         if (propertyNames.length > 0) {
             var propertyName = propertyNames[propertyNames.length - 1];
@@ -24170,6 +24579,27 @@ exports.ColorPropertyTrack = __decorate([
     effectsClass(DataType.ColorPropertyTrack)
 ], exports.ColorPropertyTrack);
 
+exports.ColorPropertyPlayableAsset = /*#__PURE__*/ function(PlayableAsset) {
+    _inherits(ColorPropertyPlayableAsset, PlayableAsset);
+    function ColorPropertyPlayableAsset() {
+        return PlayableAsset.apply(this, arguments);
+    }
+    var _proto = ColorPropertyPlayableAsset.prototype;
+    _proto.createPlayable = function createPlayable(graph) {
+        var clipPlayable = new PropertyClipPlayable(graph);
+        clipPlayable.curve = createValueGetter(this.curveData);
+        clipPlayable.value = clipPlayable.curve.getValue(0);
+        return clipPlayable;
+    };
+    return ColorPropertyPlayableAsset;
+}(PlayableAsset);
+__decorate([
+    serialize()
+], exports.ColorPropertyPlayableAsset.prototype, "curveData", void 0);
+exports.ColorPropertyPlayableAsset = __decorate([
+    effectsClass(DataType.ColorPropertyPlayableAsset)
+], exports.ColorPropertyPlayableAsset);
+
 exports.FloatPropertyPlayableAsset = /*#__PURE__*/ function(PlayableAsset) {
     _inherits(FloatPropertyPlayableAsset, PlayableAsset);
     function FloatPropertyPlayableAsset() {
@@ -24374,6 +24804,27 @@ function compareTracks(a, b) {
     }
 }
 
+exports.Vector4PropertyPlayableAsset = /*#__PURE__*/ function(PlayableAsset) {
+    _inherits(Vector4PropertyPlayableAsset, PlayableAsset);
+    function Vector4PropertyPlayableAsset() {
+        return PlayableAsset.apply(this, arguments);
+    }
+    var _proto = Vector4PropertyPlayableAsset.prototype;
+    _proto.createPlayable = function createPlayable(graph) {
+        var clipPlayable = new PropertyClipPlayable(graph);
+        clipPlayable.curve = createValueGetter(this.curveData);
+        clipPlayable.value = clipPlayable.curve.getValue(0);
+        return clipPlayable;
+    };
+    return Vector4PropertyPlayableAsset;
+}(PlayableAsset);
+__decorate([
+    serialize()
+], exports.Vector4PropertyPlayableAsset.prototype, "curveData", void 0);
+exports.Vector4PropertyPlayableAsset = __decorate([
+    effectsClass("Vector4PropertyPlayableAsset")
+], exports.Vector4PropertyPlayableAsset);
+
 exports.ObjectBindingTrack = /*#__PURE__*/ function(TrackAsset1) {
     _inherits(ObjectBindingTrack, TrackAsset1);
     function ObjectBindingTrack() {
@@ -24611,6 +25062,8 @@ exports.TextComponent = /*#__PURE__*/ function(BaseRenderComponent) {
         /**
    * 文本行数
    */ _this.lineCount = 0;
+        _this.SCALE_FACTOR = 0.1;
+        _this.ALPHA_FIX_VALUE = 1 / 255;
         _this.name = "MText" + seed$1++;
         _this.geometry = _this.createGeometry(glContext.TRIANGLES);
         if (props) {
@@ -24976,7 +25429,7 @@ var TextComponentBase = /*#__PURE__*/ function() {
         }
         //与 toDataURL() 两种方式都需要像素读取操作
         var imageData = context.getImageData(0, 0, this.canvas.width, this.canvas.height);
-        this.material.setTexture("uSampler0", Texture.createWithData(this.engine, {
+        this.material.setTexture("_MainTex", Texture.createWithData(this.engine, {
             data: new Uint8Array(imageData.data),
             width: imageData.width,
             height: imageData.height
@@ -28174,7 +28627,7 @@ var listOrder = 0;
             var itemProps = sourceItemData;
             if (passRenderLevel(sourceItemData.renderLevel, this.renderLevel)) {
                 itemProps.listIndex = listOrder++;
-                if (itemProps.type === ItemType.sprite || itemProps.type === ItemType.particle || //@ts-expect-error
+                if (itemProps.type === ItemType.sprite || itemProps.type === ItemType.particle || itemProps.type === ItemType.spine || //@ts-expect-error
                 itemProps.type === ItemType.shape) {
                     for(var _iterator2 = _create_for_of_iterator_helper_loose(itemProps.components), _step2; !(_step2 = _iterator2()).done;){
                         var componentPath = _step2.value;
@@ -28215,8 +28668,10 @@ var listOrder = 0;
                 shapeData = shape;
             }
             if (shapeData !== undefined) {
-                // @ts-expect-error 类型转换问题
-                renderContent.renderer.shape = getGeometryByShape(shapeData, split);
+                if (!("aPoint" in shapeData && "index" in shapeData)) {
+                    // @ts-expect-error 类型转换问题
+                    renderContent.renderer.shape = getGeometryByShape(shapeData, split);
+                }
             }
         }
         if ("trails" in renderContent && renderContent.trails !== undefined) {
@@ -31132,7 +31587,7 @@ registerPlugin("sprite", SpriteLoader, exports.VFXItem, true);
 registerPlugin("particle", ParticleLoader, exports.VFXItem, true);
 registerPlugin("cal", CalculateLoader, exports.VFXItem, true);
 registerPlugin("interact", InteractLoader, exports.VFXItem, true);
-var version = "2.1.0-alpha.11";
+var version = "2.1.0-alpha.13";
 logger.info("Core version: " + version + ".");
 
 exports.AbstractPlugin = AbstractPlugin;