@galacean/effects-core 2.6.7 → 2.6.8

package/dist/index.js

@@ -3,7 +3,7 @@
  * Description: Galacean Effects runtime core for the web
  * Author: Ant Group CO., Ltd.
  * Contributors: 燃然,飂兮,十弦,云垣,茂安,意绮
- * Version: v2.6.7
+ * Version: v2.6.8
  */
 
 'use strict';
@@ -4145,6 +4145,1027 @@ var Blender = /*#__PURE__*/ function() {
 Blender.normalBlendFunction = new NormalBlend();
 Blender.additiveBlendFunction = new AdditiveBlend();
 
+/**
+ * 四维向量
+ */ var Vector4 = /*#__PURE__*/ function() {
+    function Vector4(x, y, z, w) {
+        if (x === void 0) x = 0;
+        if (y === void 0) y = 0;
+        if (z === void 0) z = 0;
+        if (w === void 0) w = 0;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+    }
+    var _proto = Vector4.prototype;
+    /**
+     * 设置向量
+     * @param x - x 轴分量
+     * @param y - y 轴分量
+     * @param z - z 轴分量
+     * @param w - w 轴分量
+     * @returns
+     */ _proto.set = function set(x, y, z, w) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+        return this;
+    };
+    /**
+     * 设置零向量
+     * @returns 向量
+     */ _proto.setZero = function setZero() {
+        this.x = 0;
+        this.y = 0;
+        this.z = 0;
+        this.w = 0;
+        return this;
+    };
+    /**
+     * 通过标量数值设置向量
+     * @param num - 数值
+     * @returns 向量
+     */ _proto.setFromNumber = function setFromNumber(num) {
+        this.x = num;
+        this.y = num;
+        this.z = num;
+        this.w = num;
+        return this;
+    };
+    /**
+     * 通过数组创建向量
+     * @param array - 数组
+     * @param [offset=0] - 起始偏移值
+     * @returns 向量
+     */ _proto.setFromArray = function setFromArray(array, offset) {
+        if (offset === void 0) offset = 0;
+        var _array_offset;
+        this.x = (_array_offset = array[offset]) != null ? _array_offset : 0;
+        var _array_;
+        this.y = (_array_ = array[offset + 1]) != null ? _array_ : 0;
+        var _array_1;
+        this.z = (_array_1 = array[offset + 2]) != null ? _array_1 : 0;
+        var _array_2;
+        this.w = (_array_2 = array[offset + 3]) != null ? _array_2 : 0;
+        return this;
+    };
+    /**
+     * 拷贝向量
+     * @param v - 复制对象
+     * @returns 拷贝结果
+     */ _proto.copyFrom = function copyFrom(v) {
+        this.x = v.x;
+        this.y = v.y;
+        this.z = v.z;
+        this.w = v.w;
+        return this;
+    };
+    /**
+     * 克隆向量
+     * @returns 克隆结果
+     */ _proto.clone = function clone() {
+        return new Vector4(this.x, this.y, this.z, this.w);
+    };
+    /**
+     * 根据下标设置向量分量
+     * @param index - 下标值
+     * @param value - 分量值
+     * @returns 向量
+     */ _proto.setElement = function setElement(index, value) {
+        switch(index){
+            case 0:
+                this.x = value;
+                break;
+            case 1:
+                this.y = value;
+                break;
+            case 2:
+                this.z = value;
+                break;
+            case 3:
+                this.w = value;
+                break;
+            default:
+                console.error("index is out of range: " + index);
+        }
+        return this;
+    };
+    /**
+     * 根据下标获取向量分量
+     * @param index - 下标
+     * @returns 分量值
+     */ _proto.getElement = function getElement(index) {
+        switch(index){
+            case 0:
+                return this.x;
+            case 1:
+                return this.y;
+            case 2:
+                return this.z;
+            case 3:
+                return this.w;
+            default:
+                console.error("index is out of range: " + index);
+        }
+        return 0;
+    };
+    /**
+     * 向量相加
+     * @param right - 相加对象，向量 | 数字
+     * @returns 相加结果
+     */ _proto.add = function add(right) {
+        if (typeof right === "number") {
+            this.x += right;
+            this.y += right;
+            this.z += right;
+            this.w += right;
+        } else if (_instanceof1(right, Array)) {
+            this.x += right[0];
+            this.y += right[1];
+            this.z += right[2];
+            this.w += right[3];
+        } else {
+            this.x += right.x;
+            this.y += right.y;
+            this.z += right.z;
+            this.w += right.w;
+        }
+        return this;
+    };
+    /**
+     * 向量相加
+     * @param left - 向量
+     * @param right - 向量
+     * @returns 求和结果
+     */ _proto.addVectors = function addVectors(left, right) {
+        this.x = left.x + right.x;
+        this.y = left.y + right.y;
+        this.z = left.z + right.z;
+        this.w = left.w + right.w;
+        return this;
+    };
+    /**
+     * 向量比例缩放后相加
+     * @param right - 向量
+     * @param s - 比例
+     * @returns 求和结果
+     */ _proto.addScaledVector = function addScaledVector(right, s) {
+        this.x += right.x * s;
+        this.y += right.y * s;
+        this.z += right.z * s;
+        this.w += right.w * s;
+        return this;
+    };
+    /**
+     * 向量相减
+     * @param right - 相减对象，向量 | 数字
+     * @returns 相减结果
+     */ _proto.subtract = function subtract(right) {
+        if (typeof right === "number") {
+            this.x -= right;
+            this.y -= right;
+            this.z -= right;
+            this.w -= right;
+        } else if (_instanceof1(right, Array)) {
+            this.x -= right[0];
+            this.y -= right[1];
+            this.z -= right[2];
+            this.w -= right[3];
+        } else {
+            this.x -= right.x;
+            this.y -= right.y;
+            this.z -= right.z;
+            this.w -= right.w;
+        }
+        return this;
+    };
+    /**
+     * 向量相减
+     * @param left - 向量
+     * @param right - 向量
+     * @returns 向量
+     */ _proto.subtractVectors = function subtractVectors(left, right) {
+        this.x = left.x - right.x;
+        this.y = left.y - right.y;
+        this.z = left.z - right.z;
+        this.w = left.w - right.w;
+        return this;
+    };
+    /**
+     * 向量相乘
+     * @param right - 相乘对象，对象 | 数字
+     * @returns 向量
+     */ _proto.multiply = function multiply(right) {
+        if (typeof right === "number") {
+            this.x *= right;
+            this.y *= right;
+            this.z *= right;
+            this.w *= right;
+        } else if (_instanceof1(right, Array)) {
+            this.x *= right[0];
+            this.y *= right[1];
+            this.z *= right[2];
+            this.w *= right[3];
+        } else {
+            this.x *= right.x;
+            this.y *= right.y;
+            this.z *= right.z;
+            this.w *= right.w;
+        }
+        return this;
+    };
+    /**
+     * 向量相乘
+     * @param left - 向量
+     * @param right - 向量
+     * @returns 向量
+     */ _proto.multiplyVectors = function multiplyVectors(left, right) {
+        this.x = left.x * right.x;
+        this.y = left.y * right.y;
+        this.z = left.z * right.z;
+        this.w = left.w * right.w;
+        return this;
+    };
+    /**
+     * 向量相除
+     * @param right - 相除对象，对象 | 数字
+     * @returns 向量
+     */ _proto.divide = function divide(right) {
+        if (typeof right === "number") {
+            this.x /= right;
+            this.y /= right;
+            this.z /= right;
+            this.w /= right;
+        } else if (_instanceof1(right, Array)) {
+            this.x /= right[0];
+            this.y /= right[1];
+            this.z /= right[2];
+            this.w /= right[3];
+        } else {
+            this.x /= right.x;
+            this.y /= right.y;
+            this.z /= right.z;
+            this.w /= right.w;
+        }
+        return this;
+    };
+    /**
+     * 向量缩放
+     * @param v - 数字
+     * @returns 缩放结果
+     */ _proto.scale = function scale(v) {
+        this.x *= v;
+        this.y *= v;
+        this.z *= v;
+        this.w *= v;
+        return this;
+    };
+    /**
+     * 分量求和
+     * @returns 求和结果
+     */ _proto.sum = function sum() {
+        return this.x + this.y + this.z + this.w;
+    };
+    /**
+     * 向量求最小值
+     * @param v - 向量或数值
+     * @returns 最小值
+     */ _proto.min = function min(v) {
+        if (typeof v === "number") {
+            this.x = Math.min(this.x, v);
+            this.y = Math.min(this.y, v);
+            this.z = Math.min(this.z, v);
+            this.w = Math.min(this.w, v);
+        } else {
+            this.x = Math.min(this.x, v.x);
+            this.y = Math.min(this.y, v.y);
+            this.z = Math.min(this.z, v.z);
+            this.w = Math.min(this.w, v.w);
+        }
+        return this;
+    };
+    /**
+     * 向量求最大值
+     * @param v - 向量或数值
+     * @returns 最大值
+     */ _proto.max = function max(v) {
+        if (typeof v === "number") {
+            this.x = Math.max(this.x, v);
+            this.y = Math.max(this.y, v);
+            this.z = Math.max(this.z, v);
+            this.w = Math.max(this.w, v);
+        } else {
+            this.x = Math.max(this.x, v.x);
+            this.y = Math.max(this.y, v.y);
+            this.z = Math.max(this.z, v.z);
+            this.w = Math.max(this.w, v.w);
+        }
+        return this;
+    };
+    /**
+     * 向量阈值约束
+     * @param min - 最小值
+     * @param max - 最大值
+     * @returns 向量
+     */ _proto.clamp = function clamp(min, max) {
+        return this.max(min).min(max);
+    };
+    /**
+     * 向量向下取整
+     * @returns 取整结果
+     */ _proto.floor = function floor() {
+        this.x = Math.floor(this.x);
+        this.y = Math.floor(this.y);
+        this.z = Math.floor(this.z);
+        this.w = Math.floor(this.w);
+        return this;
+    };
+    /**
+     * 向量向上取整
+     * @returns 取整结果
+     */ _proto.ceil = function ceil() {
+        this.x = Math.ceil(this.x);
+        this.y = Math.ceil(this.y);
+        this.z = Math.ceil(this.z);
+        this.w = Math.ceil(this.w);
+        return this;
+    };
+    /**
+     * 向量四舍五入
+     * @returns 求值结果
+     */ _proto.round = function round() {
+        this.x = Math.round(this.x);
+        this.y = Math.round(this.y);
+        this.z = Math.round(this.z);
+        this.w = Math.round(this.w);
+        return this;
+    };
+    /**
+     * 向量取绝对值
+     * @returns 向量
+     */ _proto.abs = function abs() {
+        this.x = Math.abs(this.x);
+        this.y = Math.abs(this.y);
+        this.z = Math.abs(this.z);
+        this.w = Math.abs(this.w);
+        return this;
+    };
+    /**
+     * 向量取反
+     * @returns 取反结果
+     */ _proto.negate = function negate() {
+        this.x = -this.x;
+        this.y = -this.y;
+        this.z = -this.z;
+        this.w = -this.w;
+        return this;
+    };
+    /**
+     * 向量长度平方
+     * @returns 长度平方
+     */ _proto.lengthSquared = function lengthSquared() {
+        return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
+    };
+    /**
+     * 向量长度
+     * @returns 长度
+     */ _proto.length = function length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+    };
+    /**
+     * 向量归一化
+     * @returns 归一化结果
+     */ _proto.normalize = function normalize() {
+        return this.divide(this.length() || 1);
+    };
+    /**
+     * 设置向量长度
+     * @param length - 长度
+     * @returns 向量
+     */ _proto.setLength = function setLength(length) {
+        return this.normalize().multiply(length);
+    };
+    /**
+     * 向量求线性插值
+     * @param v - 向量
+     * @param alpha - 插值比例
+     * @returns 插值结果
+     */ _proto.lerp = function lerp(v, alpha) {
+        this.x += (v.x - this.x) * alpha;
+        this.y += (v.y - this.y) * alpha;
+        this.z += (v.z - this.z) * alpha;
+        this.w += (v.w - this.w) * alpha;
+        return this;
+    };
+    /**
+     * 两向量求线性插值
+     * @param v1 - 第一个向量
+     * @param v2 - 第二个向量
+     * @param alpha - 插值比例
+     * @returns 插值结果
+     */ _proto.lerpVectors = function lerpVectors(v1, v2, alpha) {
+        this.x = v1.x + (v2.x - v1.x) * alpha;
+        this.y = v1.y + (v2.y - v1.y) * alpha;
+        this.z = v1.z + (v2.z - v1.z) * alpha;
+        this.w = v1.w + (v2.w - v1.w) * alpha;
+        return this;
+    };
+    /**
+     * 向量求点积
+     * @param v - 向量
+     * @returns 点积结果
+     */ _proto.dot = function dot(v) {
+        return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
+    };
+    /**
+     * 向量判等
+     * @param v - 向量
+     * @returns 判等结果
+     */ _proto.equals = function equals(v) {
+        return v.x === this.x && v.y === this.y && v.z === this.z && v.w === this.w;
+    };
+    /**
+     * 是否零向量
+     * @returns 是否零向量
+     */ _proto.isZero = function isZero() {
+        var eps = NumberEpsilon;
+        var _this = this, x = _this.x, y = _this.y, z = _this.z, w = _this.w;
+        return Math.abs(x) <= eps && Math.abs(y) <= eps && Math.abs(z) <= eps && Math.abs(w) <= eps;
+    };
+    /**
+     * 向量转数组
+     * @returns 数组
+     */ _proto.toArray = function toArray() {
+        return [
+            this.x,
+            this.y,
+            this.z,
+            this.w
+        ];
+    };
+    _proto.toVector3 = function toVector3() {
+        return new Vector3(this.x, this.y, this.z);
+    };
+    _proto.fill = function fill(array, offset) {
+        if (offset === void 0) offset = 0;
+        array[offset] = this.x;
+        array[offset + 1] = this.y;
+        array[offset + 2] = this.z;
+        array[offset + 3] = this.w;
+    };
+    /**
+     * 生成随机向量
+     * @returns 向量
+     */ _proto.random = function random() {
+        this.x = Math.random();
+        this.y = Math.random();
+        this.z = Math.random();
+        this.w = Math.random();
+        return this;
+    };
+    /**
+     * 变换矩阵作用于向量
+     * @param m - 变换矩阵
+     * @param [out] - 输出结果，如果没有设置就直接覆盖当前值
+     * @returns 向量
+     */ _proto.applyMatrix = function applyMatrix(m, out) {
+        return m.transformVector4(this, out);
+    };
+    /**
+     * 通过标量数值创建向量
+     * @param num - 数值
+     * @returns 向量
+     */ Vector4.fromNumber = function fromNumber(num) {
+        return new Vector4().setFromNumber(num);
+    };
+    /**
+     * 通过数组创建向量
+     * @param array - 数组
+     * @param [offset=0] - 起始偏移值
+     * @returns 向量
+     */ Vector4.fromArray = function fromArray(array, offset) {
+        if (offset === void 0) offset = 0;
+        return new Vector4().setFromArray(array, offset);
+    };
+    return Vector4;
+}();
+/**
+     * 四维向量的常量
+     */ Vector4.ONE = new Vector4(1.0, 1.0, 1.0, 1.0);
+Vector4.ZERO = new Vector4(0.0, 0.0, 0.0, 0.0);
+
+var Color = /*#__PURE__*/ function() {
+    function Color(r, g, b, a) {
+        if (r === void 0) r = 0;
+        if (g === void 0) g = 0;
+        if (b === void 0) b = 0;
+        if (a === void 0) a = 0;
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+    }
+    var _proto = Color.prototype;
+    /**
+     * 设置颜色
+     * @param r - r 分量
+     * @param g - g 分量
+     * @param b - b 分量
+     * @param a - a 分量
+     * @returns
+     */ _proto.set = function set(r, g, b, a) {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+        return this;
+    };
+    /**
+     * 设置零颜色
+     * @returns
+     */ _proto.setZero = function setZero() {
+        this.r = 0;
+        this.g = 0;
+        this.b = 0;
+        this.a = 0;
+        return this;
+    };
+    /**
+     * 通过标量数值设置颜色
+     * @param num - 数值
+     * @returns
+     */ _proto.setFromNumber = function setFromNumber(num) {
+        this.r = num;
+        this.g = num;
+        this.b = num;
+        this.a = num;
+        return this;
+    };
+    /**
+     * 通过Vector4创建颜色
+     * @param v - Vector4
+     * @returns
+     */ _proto.setFromVector4 = function setFromVector4(v) {
+        this.r = v.x;
+        this.g = v.y;
+        this.b = v.z;
+        this.a = v.w;
+        return this;
+    };
+    /**
+     * 通过数组创建颜色
+     * @param array - 数组
+     * @param [offset=0] - 起始偏移值
+     * @returns
+     */ _proto.setFromArray = function setFromArray(array, offset) {
+        if (offset === void 0) offset = 0;
+        var _array_offset;
+        this.r = (_array_offset = array[offset]) != null ? _array_offset : 0;
+        var _array_;
+        this.g = (_array_ = array[offset + 1]) != null ? _array_ : 0;
+        var _array_1;
+        this.b = (_array_1 = array[offset + 2]) != null ? _array_1 : 0;
+        var _array_2;
+        this.a = (_array_2 = array[offset + 3]) != null ? _array_2 : 0;
+        return this;
+    };
+    _proto.setFromHSV = function setFromHSV(hue, saturation, value, alpha) {
+        if (alpha === void 0) alpha = 1;
+        var chroma = value * saturation;
+        var h = hue / 60;
+        var x = chroma * (1 - Math.abs(h % 2 - 1));
+        var r = 0;
+        var g = 0;
+        var b = 0;
+        if (h >= 0 && h <= 1) {
+            r = chroma;
+            g = x;
+        } else if (h >= 1 && h <= 2) {
+            r = x;
+            g = chroma;
+        } else if (h >= 2 && h <= 3) {
+            g = chroma;
+            b = x;
+        } else if (h >= 3 && h <= 4) {
+            g = x;
+            b = chroma;
+        } else if (h >= 4 && h <= 5) {
+            r = x;
+            b = chroma;
+        } else if (h >= 5 && h <= 6) {
+            r = chroma;
+            b = x;
+        }
+        var m = value - chroma;
+        return this.set(r + m, g + m, b + m, alpha);
+    };
+    _proto.setFromHexString = function setFromHexString(hex) {
+        if (hex.substring(0, 1) !== "#" || hex.length !== 9 && hex.length !== 7) {
+            return this;
+        }
+        var r = parseInt(hex.substring(1, 3), 16) / 255.0;
+        var g = parseInt(hex.substring(3, 5), 16) / 255.0;
+        var b = parseInt(hex.substring(5, 7), 16) / 255.0;
+        var a = hex.length === 9 ? parseInt(hex.substring(7, 9), 16) / 255.0 : 1.0;
+        return this.set(r, g, b, a);
+    };
+    /**
+     * 拷贝颜色
+     * @param v - 复制对象
+     * @returns 拷贝结果
+     */ _proto.copyFrom = function copyFrom(v) {
+        this.r = v.r;
+        this.g = v.g;
+        this.b = v.b;
+        this.a = v.a;
+        return this;
+    };
+    /**
+     * 克隆颜色
+     * @returns 克隆结果
+     */ _proto.clone = function clone() {
+        return new Color(this.r, this.g, this.b, this.a);
+    };
+    /**
+     * 根据下标设置颜色分量
+     * @param index - 下标值
+     * @param value - 分量值
+     * @returns
+     */ _proto.setElement = function setElement(index, value) {
+        switch(index){
+            case 0:
+                this.r = value;
+                break;
+            case 1:
+                this.g = value;
+                break;
+            case 2:
+                this.b = value;
+                break;
+            case 3:
+                this.a = value;
+                break;
+            default:
+                console.error("index is out of range: " + index);
+        }
+        return this;
+    };
+    /**
+     * 根据下标获取颜色分量
+     * @param index - 下标
+     * @returns 分量值
+     */ _proto.getElement = function getElement(index) {
+        switch(index){
+            case 0:
+                return this.r;
+            case 1:
+                return this.g;
+            case 2:
+                return this.b;
+            case 3:
+                return this.a;
+            default:
+                console.error("index is out of range: " + index);
+        }
+        return 0;
+    };
+    /**
+     * 颜色相加
+     * @param right - 相加对象，颜色 | 数字
+     * @returns 相加结果
+     */ _proto.add = function add(right) {
+        if (typeof right === "number") {
+            this.r += right;
+            this.g += right;
+            this.b += right;
+            this.a += right;
+        } else if (_instanceof1(right, Array)) {
+            this.r += right[0];
+            this.g += right[1];
+            this.b += right[2];
+            this.a += right[3];
+        } else {
+            this.r += right.r;
+            this.g += right.g;
+            this.b += right.b;
+            this.a += right.a;
+        }
+        return this;
+    };
+    /**
+     * 颜色相减
+     * @param right - 相减对象，颜色 | 数字
+     * @returns 相减结果
+     */ _proto.subtract = function subtract(right) {
+        if (typeof right === "number") {
+            this.r -= right;
+            this.g -= right;
+            this.b -= right;
+            this.a -= right;
+        } else if (_instanceof1(right, Array)) {
+            this.r -= right[0];
+            this.g -= right[1];
+            this.b -= right[2];
+            this.a -= right[3];
+        } else {
+            this.r -= right.r;
+            this.g -= right.g;
+            this.b -= right.b;
+            this.a -= right.a;
+        }
+        return this;
+    };
+    /**
+     * 颜色相乘
+     * @param right - 相乘对象，对象 | 数字
+     * @returns 颜色
+     */ _proto.multiply = function multiply(right) {
+        if (typeof right === "number") {
+            this.r *= right;
+            this.g *= right;
+            this.b *= right;
+            this.a *= right;
+        } else if (_instanceof1(right, Array)) {
+            this.r *= right[0];
+            this.g *= right[1];
+            this.b *= right[2];
+            this.a *= right[3];
+        } else {
+            this.r *= right.r;
+            this.g *= right.g;
+            this.b *= right.b;
+            this.a *= right.a;
+        }
+        return this;
+    };
+    /**
+     * 颜色相除
+     * @param right - 相除对象，对象 | 数字
+     * @returns 颜色
+     */ _proto.divide = function divide(right) {
+        if (typeof right === "number") {
+            this.r /= right;
+            this.g /= right;
+            this.b /= right;
+            this.a /= right;
+        } else if (_instanceof1(right, Array)) {
+            this.r /= right[0];
+            this.g /= right[1];
+            this.b /= right[2];
+            this.a /= right[3];
+        } else {
+            this.r /= right.r;
+            this.g /= right.g;
+            this.b /= right.b;
+            this.a /= right.a;
+        }
+        return this;
+    };
+    /**
+     * 颜色缩放
+     * @param v - 数字
+     * @returns 缩放结果
+     */ _proto.scale = function scale(v) {
+        this.r *= v;
+        this.g *= v;
+        this.b *= v;
+        this.a *= v;
+        return this;
+    };
+    /**
+     * 颜色求最小值
+     * @param v - 颜色或数值
+     * @returns 最小值
+     */ _proto.min = function min(v) {
+        if (typeof v === "number") {
+            this.r = Math.min(this.r, v);
+            this.g = Math.min(this.g, v);
+            this.b = Math.min(this.b, v);
+            this.a = Math.min(this.a, v);
+        } else {
+            this.r = Math.min(this.r, v.r);
+            this.g = Math.min(this.g, v.g);
+            this.b = Math.min(this.b, v.b);
+            this.a = Math.min(this.a, v.a);
+        }
+        return this;
+    };
+    /**
+     * 颜色求最大值
+     * @param v - 颜色或数值
+     * @returns 最大值
+     */ _proto.max = function max(v) {
+        if (typeof v === "number") {
+            this.r = Math.max(this.r, v);
+            this.g = Math.max(this.g, v);
+            this.b = Math.max(this.b, v);
+            this.a = Math.max(this.a, v);
+        } else {
+            this.r = Math.max(this.r, v.r);
+            this.g = Math.max(this.g, v.g);
+            this.b = Math.max(this.b, v.b);
+            this.a = Math.max(this.a, v.a);
+        }
+        return this;
+    };
+    /**
+     * 颜色阈值约束
+     * @param min - 最小值
+     * @param max - 最大值
+     * @returns 颜色
+     */ _proto.clamp = function clamp(min, max) {
+        return this.max(min).min(max);
+    };
+    /**
+     * 颜色求线性插值
+     * @param v - 颜色
+     * @param alpha - 插值比例
+     * @returns 插值结果
+     */ _proto.lerp = function lerp(v, alpha) {
+        this.r += (v.r - this.r) * alpha;
+        this.g += (v.g - this.g) * alpha;
+        this.b += (v.b - this.b) * alpha;
+        this.a += (v.a - this.a) * alpha;
+        return this;
+    };
+    /**
+     * 计算颜色亮度值
+     * @returns 亮度值
+     */ _proto.luminance = function luminance() {
+        return this.r * 0.3 + this.g * 0.59 + this.b * 0.11;
+    };
+    /**
+     * 颜色判等
+     * @param v - 颜色
+     * @returns 判等结果
+     */ _proto.equals = function equals(v) {
+        return v.r === this.r && v.g === this.g && v.b === this.b && v.a === this.a;
+    };
+    _proto.toLinear = function toLinear() {
+        this.r = Color.gammaToLinear(this.r);
+        this.g = Color.gammaToLinear(this.g);
+        this.b = Color.gammaToLinear(this.b);
+        return this;
+    };
+    _proto.toGamma = function toGamma() {
+        this.r = Color.linearToGamma(this.r);
+        this.g = Color.linearToGamma(this.g);
+        this.b = Color.linearToGamma(this.b);
+        return this;
+    };
+    /**
+     * 颜色转数组
+     * @returns 数组
+     */ _proto.toArray = function toArray() {
+        return [
+            this.r,
+            this.g,
+            this.b,
+            this.a
+        ];
+    };
+    _proto.toVector4 = function toVector4() {
+        return new Vector4(this.r, this.g, this.b, this.a);
+    };
+    /**
+     * RGB 颜色空间转 HSV
+     * @param result HSV 值
+     */ _proto.toHSV = function toHSV() {
+        var _this = this, r = _this.r, g = _this.g, b = _this.b, a = _this.a;
+        var max = Math.max(r, g, b);
+        var min = Math.min(r, g, b);
+        var v = max;
+        var dm = max - min;
+        var h = 0;
+        var s = 0;
+        if (max !== 0) {
+            s = dm / max;
+        }
+        if (max != min) {
+            if (max == r) {
+                h = (g - b) / dm;
+                if (g < b) {
+                    h += 6;
+                }
+            } else if (max == g) {
+                h = (b - r) / dm + 2;
+            } else if (max == b) {
+                h = (r - g) / dm + 4;
+            }
+            h *= 60;
+        }
+        return new Color(h, s, v, a);
+    };
+    _proto.toHexString = function toHexString(includeAlpha) {
+        if (includeAlpha === void 0) includeAlpha = true;
+        var R = Color.ToHex(Math.round(this.r * 255));
+        var G = Color.ToHex(Math.round(this.g * 255));
+        var B = Color.ToHex(Math.round(this.b * 255));
+        var A = Color.ToHex(Math.round(this.a * 255));
+        if (includeAlpha) {
+            return "#" + R + G + B + A;
+        } else {
+            return "#" + R + G + B;
+        }
+    };
+    _proto.fill = function fill(array, offset) {
+        if (offset === void 0) offset = 0;
+        array[offset] = this.r;
+        array[offset + 1] = this.g;
+        array[offset + 2] = this.b;
+        array[offset + 3] = this.a;
+    };
+    /**
+     * 通过标量数值创建颜色
+     * @param num - 数值
+     * @returns
+     */ Color.fromNumber = function fromNumber(num) {
+        return new Color().setFromNumber(num);
+    };
+    /**
+     * 通过数组创建颜色
+     * @param array - 数组
+     * @param [offset=0] - 起始偏移值
+     * @returns
+     */ Color.fromArray = function fromArray(array, offset) {
+        if (offset === void 0) offset = 0;
+        return new Color().setFromArray(array, offset);
+    };
+    /**
+     * 通过 hex 字符串创建颜色
+     * @param hex - hex 字符串
+     * @returns
+     */ Color.fromHexString = function fromHexString(hex) {
+        return new Color().setFromHexString(hex);
+    };
+    Color.fromHSV = function fromHSV(hue, saturation, value, alpha) {
+        if (alpha === void 0) alpha = 1;
+        return new Color().setFromHSV(hue, saturation, value, alpha);
+    };
+    /**
+     * 颜色值从 Gamma 空间转到线性空间
+     * @param v - Gamma 空间颜色值
+     * @returns 线性空间颜色值
+     */ Color.gammaToLinear = function gammaToLinear(v) {
+        if (v <= 0.0) {
+            return 0.0;
+        } else if (v <= 0.04045) {
+            return v / 12.92;
+        } else if (v < 1.0) {
+            return Math.pow((v + 0.055) / 1.055, 2.4);
+        } else {
+            return Math.pow(v, 2.4);
+        }
+    };
+    /**
+     * 颜色值从线性空间转到 Gamma 空间
+     * @param value - 线性空间颜色值
+     * @returns Gamma 空间颜色值
+     */ Color.linearToGamma = function linearToGamma(value) {
+        if (value <= 0.0) {
+            return 0.0;
+        } else if (value < 0.0031308) {
+            return 12.92 * value;
+        } else if (value < 1.0) {
+            return 1.055 * Math.pow(value, 0.41666) - 0.055;
+        } else {
+            return Math.pow(value, 0.41666);
+        }
+    };
+    Color.ToHex = function ToHex(i) {
+        var str = i.toString(16);
+        if (i <= 15) {
+            return ("0" + str).toUpperCase();
+        }
+        return str.toUpperCase();
+    };
+    return Color;
+}();
+/**
+     * 颜色的常量
+     */ Color.BLACK = new Color(0, 0, 0, 1) // 纯黑色
+;
+Color.BLUE = new Color(0, 0, 1, 1) // 纯蓝色
+;
+Color.CLEAR = new Color(0, 0, 0, 0) // 完全透明
+;
+Color.CYAN = new Color(0, 1, 1, 1) // 青色
+;
+Color.GRAY = new Color(0.5, 0.5, 0.5, 1) // 灰色
+;
+Color.GREEN = new Color(0, 1, 0, 1) // 纯绿色
+;
+Color.MAGENTA = new Color(1, 0, 1, 1) // 洋红色
+;
+Color.RED = new Color(1, 0, 0, 1) // 纯红色
+;
+Color.WHITE = new Color(1, 1, 1, 1) // 纯白色
+;
+Color.YELLOW = new Color(1, 0.92, 0.016, 1) // 黄色
+;
+
 var NodeTransform = /*#__PURE__*/ function() {
     function NodeTransform(transform) {
         this.position = new Vector3();
@@ -4184,7 +5205,7 @@ var Pose = /*#__PURE__*/ function() {
         }
         for(var _iterator2 = _create_for_of_iterator_helper_loose(skeleton.defaultColorPropertyValues), _step2; !(_step2 = _iterator2()).done;){
             var defaultColor = _step2.value;
-            this.colorPropertyValues.push(defaultColor);
+            this.colorPropertyValues.push(new Color().copyFrom(defaultColor));
         }
     }
     var _proto = Pose.prototype;
@@ -5600,1059 +6621,548 @@ var Skeleton = /*#__PURE__*/ function() {
         }
         var targetBone = this.findTarget(path);
         if (!targetBone) {
-            return;
-        }
-        this.parentSpaceTransforms.push(new NodeTransform(targetBone.transform));
-        this.animatedTransforms.push(targetBone.transform);
-        this.pathToBoneIndex.set(path, this.parentSpaceTransforms.length - 1);
-    };
-    _proto.addRecordedProperty = function addRecordedProperty(path, className, property, type) {
-        var totalPath = path + className + property;
-        if (this.pathToObjectIndex.get(totalPath) !== undefined) {
-            return;
-        }
-        var targetBone = this.findTarget(path);
-        if (!targetBone) {
-            return;
-        }
-        var animatedComponentOrItem;
-        // Find target component or VFXItem
-        if (className === VFXItemType) {
-            animatedComponentOrItem = targetBone;
-        } else {
-            animatedComponentOrItem = targetBone.getComponent(getClass(className));
-        }
-        if (!animatedComponentOrItem) {
-            console.error("The " + className + " Component was not found.");
-        }
-        // Find last animated object by path
-        var propertyNames = property.split(".");
-        var lastPropertyName = propertyNames[propertyNames.length - 1];
-        var target = animatedComponentOrItem;
-        for(var i = 0; i < propertyNames.length - 1; i++){
-            var _$property = target[propertyNames[i]];
-            if (_$property === undefined) {
-                console.error("The " + propertyNames[i] + " property of " + target + " was not found.");
-            }
-            target = _$property;
-        }
-        var animatedObject = {
-            target: target,
-            property: lastPropertyName
-        };
-        switch(type){
-            case 0:
-                this.floatAnimatedObjects.push(animatedObject);
-                this.defaultFloatPropertyValues.push(target[lastPropertyName]);
-                this.pathToObjectIndex.set(totalPath, this.floatAnimatedObjects.length - 1);
-                break;
-            case 1:
-                this.colorAnimatedObjects.push(animatedObject);
-                this.defaultColorPropertyValues.push(target[lastPropertyName]);
-                this.pathToObjectIndex.set(totalPath, this.colorAnimatedObjects.length - 1);
-        }
-    };
-    _proto.findTarget = function findTarget(boneName) {
-        if (boneName === "") {
-            return this.rootBone;
-        }
-        var itemNames = boneName.split("/");
-        var currentItem = this.rootBone;
-        for(var _iterator = _create_for_of_iterator_helper_loose(itemNames), _step; !(_step = _iterator()).done;){
-            var itemName = _step.value;
-            var target = currentItem.find(itemName);
-            if (!target) {
-                return null;
-            }
-            currentItem = target;
-        }
-        return currentItem;
-    };
-    return Skeleton;
-}();
-
-var GraphInstance = /*#__PURE__*/ function() {
-    function GraphInstance(graphAsset, rootBone) {
-        this.graphAsset = graphAsset;
-        this.nodes = [];
-        this.context = new GraphContext();
-        // Initialize skeleton
-        var recordProperties = {
-            position: [],
-            scale: [],
-            rotation: [],
-            euler: [],
-            floats: [],
-            colors: []
-        };
-        for(var _iterator = _create_for_of_iterator_helper_loose(graphAsset.graphDataSet.resources), _step; !(_step = _iterator()).done;){
-            var animationClip = _step.value;
-            if (!animationClip) {
-                continue;
-            }
-            for(var _iterator1 = _create_for_of_iterator_helper_loose(animationClip.positionCurves), _step1; !(_step1 = _iterator1()).done;){
-                var positionCurve = _step1.value;
-                recordProperties.position.push(positionCurve.path);
-            }
-            for(var _iterator2 = _create_for_of_iterator_helper_loose(animationClip.rotationCurves), _step2; !(_step2 = _iterator2()).done;){
-                var rotationCurve = _step2.value;
-                recordProperties.rotation.push(rotationCurve.path);
-            }
-            for(var _iterator3 = _create_for_of_iterator_helper_loose(animationClip.scaleCurves), _step3; !(_step3 = _iterator3()).done;){
-                var scaleCurve = _step3.value;
-                recordProperties.scale.push(scaleCurve.path);
-            }
-            for(var _iterator4 = _create_for_of_iterator_helper_loose(animationClip.eulerCurves), _step4; !(_step4 = _iterator4()).done;){
-                var eulerCurve = _step4.value;
-                recordProperties.euler.push(eulerCurve.path);
-            }
-            for(var _iterator5 = _create_for_of_iterator_helper_loose(animationClip.floatCurves), _step5; !(_step5 = _iterator5()).done;){
-                var floatCurve = _step5.value;
-                recordProperties.floats.push(floatCurve);
-            }
-            for(var _iterator6 = _create_for_of_iterator_helper_loose(animationClip.colorCurves), _step6; !(_step6 = _iterator6()).done;){
-                var colorCurve = _step6.value;
-                recordProperties.colors.push(colorCurve);
-            }
-        }
-        this.skeleton = new Skeleton(rootBone, recordProperties);
-        // create PoseResult
-        this.result = new PoseResult(this.skeleton);
-        this.context.skeleton = this.skeleton;
-        // instantiate graph nodes
-        var instantiationContext = new InstantiationContext();
-        instantiationContext.nodes = this.nodes;
-        instantiationContext.nodeDatas = graphAsset.nodeDatas;
-        instantiationContext.dataSet = graphAsset.graphDataSet;
-        for(var i = 0; i < graphAsset.nodeDatas.length; i++){
-            if (!instantiationContext.nodes[i]) {
-                graphAsset.nodeDatas[i].instantiate(instantiationContext);
-            }
-        }
-        this.rootNode = this.nodes[graphAsset.rootNodeIndex];
-    }
-    var _proto = GraphInstance.prototype;
-    _proto.evaluateGraph = function evaluateGraph(deltaTime) {
-        this.context.update(deltaTime);
-        if (!this.rootNode.isInitialized()) {
-            this.resetGraphState();
-        }
-        // Evaluate the entire animation graph starting from the rootNode
-        if (this.rootNode) {
-            this.result = this.rootNode.evaluate(this.context, this.result);
-        }
-        // Reset trigger nodes
-        for(var i = 0; i < this.getNumControlParameters(); i++){
-            var controlParameterNode = this.nodes[i];
-            if (_instanceof1(controlParameterNode, ControlParameterTriggerNode)) {
-                controlParameterNode.setValue(false);
-            }
-        }
-        return this.result;
-    };
-    _proto.isInitialized = function isInitialized() {
-        return this.rootNode && this.rootNode.isInitialized();
-    };
-    // General Node Info
-    //-------------------------------------------------------------------------
-    _proto.isNodeActive = function isNodeActive(nodeIdx) {
-        return this.isControlParameter(nodeIdx) || this.nodes[nodeIdx].isNodeActive(this.context.updateID);
-    };
-    // Graph State
-    //-------------------------------------------------------------------------
-    _proto.resetGraphState = function resetGraphState() {
-        if (this.rootNode.isInitialized()) {
-            this.rootNode.shutdown(this.context);
-        }
-        this.context.updateID++; // Bump the update ID to ensure that any initialization code that relies on it is dirtied.
-        this.rootNode.initialize(this.context);
-    };
-    // Control Parameters
-    //-------------------------------------------------------------------------
-    _proto.getNumControlParameters = function getNumControlParameters() {
-        return this.graphAsset.controlParameterIDs.length;
-    };
-    _proto.getControlParameterIndex = function getControlParameterIndex(parameterID) {
-        var parameterLookupMap = this.graphAsset.parameterLookupMap;
-        var res = parameterLookupMap.get(parameterID);
-        if (res !== undefined) {
-            return res;
-        }
-        console.warn("Parameter '" + parameterID + "' does not exist.");
-        return InvalidIndex;
-    };
-    _proto.getControlParameterID = function getControlParameterID(parameterNodeIndex) {
-        return this.graphAsset.controlParameterIDs[parameterNodeIndex];
-    };
-    _proto.setBool = function setBool(name, value) {
-        this.setControlParameterValue(name, value);
-    };
-    _proto.setFloat = function setFloat(name, value) {
-        this.setControlParameterValue(name, value);
-    };
-    _proto.setTrigger = function setTrigger(name) {
-        this.setControlParameterValue(name, true);
-    };
-    _proto.resetTrigger = function resetTrigger(name) {
-        this.setControlParameterValue(name, false);
-    };
-    // Debug Information
-    //-------------------------------------------------------------------------
-    _proto.getPoseNodeDebugInfo = function getPoseNodeDebugInfo(nodeIdx) {
-        var node = this.nodes[nodeIdx];
-        return node.getDebugInfo();
-    };
-    _proto.getRuntimeNodeDebugValue = function getRuntimeNodeDebugValue(nodeIdx) {
-        var valueNode = this.nodes[nodeIdx];
-        return valueNode.getValue(this.context);
-    };
-    _proto.getNodeDebugInstance = function getNodeDebugInstance(nodeIdx) {
-        return this.nodes[nodeIdx];
-    };
-    _proto.isControlParameter = function isControlParameter(nodeIdx) {
-        return nodeIdx < this.getNumControlParameters();
-    };
-    _proto.setControlParameterValue = function setControlParameterValue(name, value) {
-        var index = this.getControlParameterIndex(name);
-        if (index !== InvalidIndex) {
-            this.nodes[index].setValue(value);
-        }
-    };
-    return GraphInstance;
-}();
-
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-
-/**
- * @since 2.0.0
- */ var Component = /*#__PURE__*/ function(EffectsObject) {
-    _inherits(Component, EffectsObject);
-    function Component() {
-        var _this;
-        _this = EffectsObject.apply(this, arguments) || this;
-        _this.isAwakeCalled = false;
-        _this.isStartCalled = false;
-        _this.isEnableCalled = false;
-        _this._enabled = true;
-        return _this;
-    }
-    var _proto = Component.prototype;
-    /**
-   * 生命周期函数，初始化后调用，生命周期内只调用一次
-   */ _proto.onAwake = function onAwake() {
-    // OVERRIDE
-    };
-    /**
-   * 在 enabled 变为 true 时触发
-   */ _proto.onEnable = function onEnable() {
-    // OVERRIDE
-    };
-    /**
-   * 在 enabled 变为 false 时触发
-   */ _proto.onDisable = function onDisable() {
-    // OVERRIDE
-    };
-    /**
-   * 生命周期函数，在第一次 update 前调用，生命周期内只调用一次
-   */ _proto.onStart = function onStart() {
-    // OVERRIDE
-    };
-    /**
-   * 生命周期函数，每帧调用一次
-   */ _proto.onUpdate = function onUpdate(dt) {
-    // OVERRIDE
-    };
-    /**
-   * 生命周期函数，每帧调用一次，在 update 之后调用
-   */ _proto.onLateUpdate = function onLateUpdate(dt) {
-    // OVERRIDE
-    };
-    /**
-   * 生命周期函数，在组件销毁时调用
-   */ _proto.onDestroy = function onDestroy() {
-    // OVERRIDE
-    };
-    /**
-   * @internal
-   */ _proto.enable = function enable() {
-        if (this.item.composition) {
-            this.item.composition.sceneTicking.addComponent(this);
-            this.isEnableCalled = true;
-        }
-        this.onEnable();
-    };
-    /**
-   * @internal
-   */ _proto.disable = function disable() {
-        this.onDisable();
-        if (this.item.composition) {
-            this.isEnableCalled = false;
-            this.item.composition.sceneTicking.removeComponent(this);
-        }
-    };
-    _proto.setVFXItem = function setVFXItem(item) {
-        this.item = item;
-        if (item.isDuringPlay) {
-            if (!this.isAwakeCalled) {
-                this.onAwake();
-                this.isAwakeCalled = true;
-            }
-            if (item.isActive && this.enabled) {
-                this.start();
-                this.enable();
-            }
-        }
-    };
-    _proto.fromData = function fromData(data) {
-        EffectsObject.prototype.fromData.call(this, data);
-    };
-    _proto.dispose = function dispose() {
-        if (this.isEnableCalled) {
-            this.disable();
-        }
-        if (this.isAwakeCalled) {
-            this.isAwakeCalled = false;
-            this.onDestroy();
-        }
-        if (this.item) {
-            removeItem(this.item.components, this);
-        }
-    };
-    _proto.start = function start() {
-        if (this.isStartCalled) {
-            return;
-        }
-        this.isStartCalled = true;
-        this.onStart();
-    };
-    _create_class(Component, [
-        {
-            key: "transform",
-            get: /**
-   * 附加到的 VFXItem 对象 Transform 组件
-   */ function get() {
-                return this.item.transform;
-            }
-        },
-        {
-            key: "isActiveAndEnabled",
-            get: /**
-   * 组件是否可以更新，true 更新，false 不更新
-   */ function get() {
-                return this.item.isActive && this.enabled;
-            }
-        },
-        {
-            key: "enabled",
-            get: function get() {
-                return this._enabled;
-            },
-            set: function set(value) {
-                if (this.enabled !== value) {
-                    this._enabled = value;
-                    if (value) {
-                        if (this.isActiveAndEnabled) {
-                            this.enable();
-                            if (!this.isStartCalled) {
-                                this.onStart();
-                                this.isStartCalled = true;
-                            }
-                        }
-                    } else {
-                        if (this.isEnableCalled) {
-                            this.disable();
-                        }
-                    }
-                }
-            }
-        }
-    ]);
-    return Component;
-}(EffectsObject);
-__decorate([
-    serialize()
-], Component.prototype, "item", void 0);
-__decorate([
-    serialize()
-], Component.prototype, "_enabled", void 0);
-/**
- * @since 2.0.0
- * @deprecated 2.4.0 Please use Component instead
- */ var Behaviour = /*#__PURE__*/ function(Component) {
-    _inherits(Behaviour, Component);
-    function Behaviour() {
-        return Component.apply(this, arguments);
-    }
-    var _proto = Behaviour.prototype;
-    _proto.setVFXItem = function setVFXItem(item) {
-        Component.prototype.setVFXItem.call(this, item);
-    };
-    _proto.dispose = function dispose() {
-        Component.prototype.dispose.call(this);
-    };
-    return Behaviour;
-}(Component);
-
-exports.Animator = /*#__PURE__*/ function(Component) {
-    _inherits(Animator, Component);
-    function Animator() {
-        var _this;
-        _this = Component.apply(this, arguments) || this;
-        /**
-   * @internal
-   */ _this.graph = null;
-        _this.graphAsset = null;
-        return _this;
-    }
-    var _proto = Animator.prototype;
-    _proto.setBool = function setBool(name, value) {
-        if (this.graph) {
-            this.graph.setBool(name, value);
-        }
-    };
-    _proto.setFloat = function setFloat(name, value) {
-        if (this.graph) {
-            this.graph.setFloat(name, value);
-        }
-    };
-    _proto.setTrigger = function setTrigger(name) {
-        if (this.graph) {
-            this.graph.setTrigger(name);
-        }
-    };
-    _proto.resetTrigger = function resetTrigger(name) {
-        if (this.graph) {
-            this.graph.resetTrigger(name);
+            return;
         }
+        this.parentSpaceTransforms.push(new NodeTransform(targetBone.transform));
+        this.animatedTransforms.push(targetBone.transform);
+        this.pathToBoneIndex.set(path, this.parentSpaceTransforms.length - 1);
     };
-    _proto.onStart = function onStart() {
-        if (this.graphAsset) {
-            this.graph = new GraphInstance(this.graphAsset, this.item);
+    _proto.addRecordedProperty = function addRecordedProperty(path, className, property, type) {
+        var totalPath = path + className + property;
+        if (this.pathToObjectIndex.get(totalPath) !== undefined) {
+            return;
         }
-    };
-    _proto.onUpdate = function onUpdate(dt) {
-        if (!this.graph) {
+        var targetBone = this.findTarget(path);
+        if (!targetBone) {
             return;
         }
-        var result = this.graph.evaluateGraph(dt / 1000);
-        // Apply transform animation
-        //-------------------------------------------------------------------------
-        var animatedTransforms = this.graph.skeleton.animatedTransforms;
-        for(var i = 0; i < animatedTransforms.length; i++){
-            var position = result.pose.parentSpaceTransforms[i].position;
-            var rotation = result.pose.parentSpaceTransforms[i].rotation;
-            var scale = result.pose.parentSpaceTransforms[i].scale;
-            var euler = result.pose.parentSpaceTransforms[i].euler;
-            animatedTransforms[i].setPosition(position.x, position.y, position.z);
-            animatedTransforms[i].setScale(scale.x, scale.y, scale.z);
-            if (this.graph.skeleton.useEuler) {
-                animatedTransforms[i].setRotation(euler.x, euler.y, euler.z);
-            } else {
-                animatedTransforms[i].setQuaternion(rotation.x, rotation.y, rotation.z, rotation.w);
-            }
+        var animatedComponentOrItem;
+        // Find target component or VFXItem
+        if (className === VFXItemType) {
+            animatedComponentOrItem = targetBone;
+        } else {
+            animatedComponentOrItem = targetBone.getComponent(getClass(className));
         }
-        // Apply property animation
-        //-------------------------------------------------------------------------
-        var floatAnimatedObjects = this.graph.skeleton.floatAnimatedObjects;
-        for(var i1 = 0; i1 < floatAnimatedObjects.length; i1++){
-            var animatedObject = floatAnimatedObjects[i1];
-            var property = animatedObject.property;
-            animatedObject.target[property] = result.pose.floatPropertyValues[i1];
+        if (!animatedComponentOrItem) {
+            console.error("The " + className + " Component was not found.");
         }
-        var colorAnimatedObjects = this.graph.skeleton.colorAnimatedObjects;
-        for(var i2 = 0; i2 < colorAnimatedObjects.length; i2++){
-            var animatedObject1 = colorAnimatedObjects[i2];
-            var property1 = animatedObject1.property;
-            animatedObject1.target[property1] = result.pose.colorPropertyValues[i2];
+        // Find last animated object by path
+        var propertyNames = property.split(".");
+        var lastPropertyName = propertyNames[propertyNames.length - 1];
+        var target = animatedComponentOrItem;
+        for(var i = 0; i < propertyNames.length - 1; i++){
+            var _$property = target[propertyNames[i]];
+            if (_$property === undefined) {
+                console.error("The " + propertyNames[i] + " property of " + target + " was not found.");
+            }
+            target = _$property;
+        }
+        var animatedObject = {
+            target: target,
+            property: lastPropertyName
+        };
+        switch(type){
+            case 0:
+                this.floatAnimatedObjects.push(animatedObject);
+                this.defaultFloatPropertyValues.push(target[lastPropertyName]);
+                this.pathToObjectIndex.set(totalPath, this.floatAnimatedObjects.length - 1);
+                break;
+            case 1:
+                this.colorAnimatedObjects.push(animatedObject);
+                this.defaultColorPropertyValues.push(new Color().copyFrom(target[lastPropertyName]));
+                this.pathToObjectIndex.set(totalPath, this.colorAnimatedObjects.length - 1);
         }
     };
-    _proto.fromData = function fromData(data) {
-        this.graphAsset = this.engine.findObject(data.graphAsset);
+    _proto.findTarget = function findTarget(boneName) {
+        if (boneName === "") {
+            return this.rootBone;
+        }
+        var itemNames = boneName.split("/");
+        var currentItem = this.rootBone;
+        for(var _iterator = _create_for_of_iterator_helper_loose(itemNames), _step; !(_step = _iterator()).done;){
+            var itemName = _step.value;
+            var target = currentItem.find(itemName);
+            if (!target) {
+                return null;
+            }
+            currentItem = target;
+        }
+        return currentItem;
     };
-    return Animator;
-}(Component);
-exports.Animator = __decorate([
-    effectsClass("Animator")
-], exports.Animator);
+    return Skeleton;
+}();
 
-/**
- * 所有渲染组件的基类
- * @since 2.0.0
- */ var RendererComponent = /*#__PURE__*/ function(Component) {
-    _inherits(RendererComponent, Component);
-    function RendererComponent() {
-        var _this;
-        _this = Component.apply(this, arguments) || this;
-        _this.materials = [];
-        _this._priority = 0;
-        return _this;
-    }
-    var _proto = RendererComponent.prototype;
-    _proto.render = function render(renderer) {};
-    _proto.onEnable = function onEnable() {
-        var _this_item_composition;
-        (_this_item_composition = this.item.composition) == null ? void 0 : _this_item_composition.renderFrame.addMeshToDefaultRenderPass(this);
-    };
-    _proto.onDisable = function onDisable() {
-        var _this_item_composition;
-        (_this_item_composition = this.item.composition) == null ? void 0 : _this_item_composition.renderFrame.removeMeshFromDefaultRenderPass(this);
-    };
-    _create_class(RendererComponent, [
-        {
-            key: "priority",
-            get: function get() {
-                return this._priority;
-            },
-            set: function set(value) {
-                this._priority = value;
+var GraphInstance = /*#__PURE__*/ function() {
+    function GraphInstance(graphAsset, rootBone) {
+        this.graphAsset = graphAsset;
+        this.nodes = [];
+        this.context = new GraphContext();
+        // Initialize skeleton
+        var recordProperties = {
+            position: [],
+            scale: [],
+            rotation: [],
+            euler: [],
+            floats: [],
+            colors: []
+        };
+        for(var _iterator = _create_for_of_iterator_helper_loose(graphAsset.graphDataSet.resources), _step; !(_step = _iterator()).done;){
+            var animationClip = _step.value;
+            if (!animationClip) {
+                continue;
             }
-        },
-        {
-            key: "material",
-            get: function get() {
-                return this.materials[0];
-            },
-            set: function set(material) {
-                if (this.materials.length === 0) {
-                    this.materials.push(material);
-                } else {
-                    this.materials[0] = material;
-                }
+            for(var _iterator1 = _create_for_of_iterator_helper_loose(animationClip.positionCurves), _step1; !(_step1 = _iterator1()).done;){
+                var positionCurve = _step1.value;
+                recordProperties.position.push(positionCurve.path);
+            }
+            for(var _iterator2 = _create_for_of_iterator_helper_loose(animationClip.rotationCurves), _step2; !(_step2 = _iterator2()).done;){
+                var rotationCurve = _step2.value;
+                recordProperties.rotation.push(rotationCurve.path);
+            }
+            for(var _iterator3 = _create_for_of_iterator_helper_loose(animationClip.scaleCurves), _step3; !(_step3 = _iterator3()).done;){
+                var scaleCurve = _step3.value;
+                recordProperties.scale.push(scaleCurve.path);
+            }
+            for(var _iterator4 = _create_for_of_iterator_helper_loose(animationClip.eulerCurves), _step4; !(_step4 = _iterator4()).done;){
+                var eulerCurve = _step4.value;
+                recordProperties.euler.push(eulerCurve.path);
+            }
+            for(var _iterator5 = _create_for_of_iterator_helper_loose(animationClip.floatCurves), _step5; !(_step5 = _iterator5()).done;){
+                var floatCurve = _step5.value;
+                recordProperties.floats.push(floatCurve);
+            }
+            for(var _iterator6 = _create_for_of_iterator_helper_loose(animationClip.colorCurves), _step6; !(_step6 = _iterator6()).done;){
+                var colorCurve = _step6.value;
+                recordProperties.colors.push(colorCurve);
             }
         }
-    ]);
-    return RendererComponent;
-}(Component);
-__decorate([
-    serialize()
-], RendererComponent.prototype, "materials", void 0);
-__decorate([
-    serialize()
-], RendererComponent.prototype, "_priority", void 0);
-
-/**
- * 四维向量
- */ var Vector4 = /*#__PURE__*/ function() {
-    function Vector4(x, y, z, w) {
-        if (x === void 0) x = 0;
-        if (y === void 0) y = 0;
-        if (z === void 0) z = 0;
-        if (w === void 0) w = 0;
-        this.x = x;
-        this.y = y;
-        this.z = z;
-        this.w = w;
+        this.skeleton = new Skeleton(rootBone, recordProperties);
+        // create PoseResult
+        this.result = new PoseResult(this.skeleton);
+        this.context.skeleton = this.skeleton;
+        // instantiate graph nodes
+        var instantiationContext = new InstantiationContext();
+        instantiationContext.nodes = this.nodes;
+        instantiationContext.nodeDatas = graphAsset.nodeDatas;
+        instantiationContext.dataSet = graphAsset.graphDataSet;
+        for(var i = 0; i < graphAsset.nodeDatas.length; i++){
+            if (!instantiationContext.nodes[i]) {
+                graphAsset.nodeDatas[i].instantiate(instantiationContext);
+            }
+        }
+        this.rootNode = this.nodes[graphAsset.rootNodeIndex];
     }
-    var _proto = Vector4.prototype;
-    /**
-     * 设置向量
-     * @param x - x 轴分量
-     * @param y - y 轴分量
-     * @param z - z 轴分量
-     * @param w - w 轴分量
-     * @returns
-     */ _proto.set = function set(x, y, z, w) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-        this.w = w;
-        return this;
-    };
-    /**
-     * 设置零向量
-     * @returns 向量
-     */ _proto.setZero = function setZero() {
-        this.x = 0;
-        this.y = 0;
-        this.z = 0;
-        this.w = 0;
-        return this;
-    };
-    /**
-     * 通过标量数值设置向量
-     * @param num - 数值
-     * @returns 向量
-     */ _proto.setFromNumber = function setFromNumber(num) {
-        this.x = num;
-        this.y = num;
-        this.z = num;
-        this.w = num;
-        return this;
-    };
-    /**
-     * 通过数组创建向量
-     * @param array - 数组
-     * @param [offset=0] - 起始偏移值
-     * @returns 向量
-     */ _proto.setFromArray = function setFromArray(array, offset) {
-        if (offset === void 0) offset = 0;
-        var _array_offset;
-        this.x = (_array_offset = array[offset]) != null ? _array_offset : 0;
-        var _array_;
-        this.y = (_array_ = array[offset + 1]) != null ? _array_ : 0;
-        var _array_1;
-        this.z = (_array_1 = array[offset + 2]) != null ? _array_1 : 0;
-        var _array_2;
-        this.w = (_array_2 = array[offset + 3]) != null ? _array_2 : 0;
-        return this;
+    var _proto = GraphInstance.prototype;
+    _proto.evaluateGraph = function evaluateGraph(deltaTime) {
+        this.context.update(deltaTime);
+        if (!this.rootNode.isInitialized()) {
+            this.resetGraphState();
+        }
+        // Evaluate the entire animation graph starting from the rootNode
+        if (this.rootNode) {
+            this.result = this.rootNode.evaluate(this.context, this.result);
+        }
+        // Reset trigger nodes
+        for(var i = 0; i < this.getNumControlParameters(); i++){
+            var controlParameterNode = this.nodes[i];
+            if (_instanceof1(controlParameterNode, ControlParameterTriggerNode)) {
+                controlParameterNode.setValue(false);
+            }
+        }
+        return this.result;
     };
-    /**
-     * 拷贝向量
-     * @param v - 复制对象
-     * @returns 拷贝结果
-     */ _proto.copyFrom = function copyFrom(v) {
-        this.x = v.x;
-        this.y = v.y;
-        this.z = v.z;
-        this.w = v.w;
-        return this;
+    _proto.isInitialized = function isInitialized() {
+        return this.rootNode && this.rootNode.isInitialized();
     };
-    /**
-     * 克隆向量
-     * @returns 克隆结果
-     */ _proto.clone = function clone() {
-        return new Vector4(this.x, this.y, this.z, this.w);
+    // General Node Info
+    //-------------------------------------------------------------------------
+    _proto.isNodeActive = function isNodeActive(nodeIdx) {
+        return this.isControlParameter(nodeIdx) || this.nodes[nodeIdx].isNodeActive(this.context.updateID);
     };
-    /**
-     * 根据下标设置向量分量
-     * @param index - 下标值
-     * @param value - 分量值
-     * @returns 向量
-     */ _proto.setElement = function setElement(index, value) {
-        switch(index){
-            case 0:
-                this.x = value;
-                break;
-            case 1:
-                this.y = value;
-                break;
-            case 2:
-                this.z = value;
-                break;
-            case 3:
-                this.w = value;
-                break;
-            default:
-                console.error("index is out of range: " + index);
+    // Graph State
+    //-------------------------------------------------------------------------
+    _proto.resetGraphState = function resetGraphState() {
+        if (this.rootNode.isInitialized()) {
+            this.rootNode.shutdown(this.context);
         }
-        return this;
+        this.context.updateID++; // Bump the update ID to ensure that any initialization code that relies on it is dirtied.
+        this.rootNode.initialize(this.context);
     };
-    /**
-     * 根据下标获取向量分量
-     * @param index - 下标
-     * @returns 分量值
-     */ _proto.getElement = function getElement(index) {
-        switch(index){
-            case 0:
-                return this.x;
-            case 1:
-                return this.y;
-            case 2:
-                return this.z;
-            case 3:
-                return this.w;
-            default:
-                console.error("index is out of range: " + index);
-        }
-        return 0;
+    // Control Parameters
+    //-------------------------------------------------------------------------
+    _proto.getNumControlParameters = function getNumControlParameters() {
+        return this.graphAsset.controlParameterIDs.length;
     };
-    /**
-     * 向量相加
-     * @param right - 相加对象，向量 | 数字
-     * @returns 相加结果
-     */ _proto.add = function add(right) {
-        if (typeof right === "number") {
-            this.x += right;
-            this.y += right;
-            this.z += right;
-            this.w += right;
-        } else if (_instanceof1(right, Array)) {
-            this.x += right[0];
-            this.y += right[1];
-            this.z += right[2];
-            this.w += right[3];
-        } else {
-            this.x += right.x;
-            this.y += right.y;
-            this.z += right.z;
-            this.w += right.w;
+    _proto.getControlParameterIndex = function getControlParameterIndex(parameterID) {
+        var parameterLookupMap = this.graphAsset.parameterLookupMap;
+        var res = parameterLookupMap.get(parameterID);
+        if (res !== undefined) {
+            return res;
         }
-        return this;
-    };
-    /**
-     * 向量相加
-     * @param left - 向量
-     * @param right - 向量
-     * @returns 求和结果
-     */ _proto.addVectors = function addVectors(left, right) {
-        this.x = left.x + right.x;
-        this.y = left.y + right.y;
-        this.z = left.z + right.z;
-        this.w = left.w + right.w;
-        return this;
+        console.warn("Parameter '" + parameterID + "' does not exist.");
+        return InvalidIndex;
     };
-    /**
-     * 向量比例缩放后相加
-     * @param right - 向量
-     * @param s - 比例
-     * @returns 求和结果
-     */ _proto.addScaledVector = function addScaledVector(right, s) {
-        this.x += right.x * s;
-        this.y += right.y * s;
-        this.z += right.z * s;
-        this.w += right.w * s;
-        return this;
+    _proto.getControlParameterID = function getControlParameterID(parameterNodeIndex) {
+        return this.graphAsset.controlParameterIDs[parameterNodeIndex];
     };
-    /**
-     * 向量相减
-     * @param right - 相减对象，向量 | 数字
-     * @returns 相减结果
-     */ _proto.subtract = function subtract(right) {
-        if (typeof right === "number") {
-            this.x -= right;
-            this.y -= right;
-            this.z -= right;
-            this.w -= right;
-        } else if (_instanceof1(right, Array)) {
-            this.x -= right[0];
-            this.y -= right[1];
-            this.z -= right[2];
-            this.w -= right[3];
-        } else {
-            this.x -= right.x;
-            this.y -= right.y;
-            this.z -= right.z;
-            this.w -= right.w;
-        }
-        return this;
+    _proto.setBool = function setBool(name, value) {
+        this.setControlParameterValue(name, value);
     };
-    /**
-     * 向量相减
-     * @param left - 向量
-     * @param right - 向量
-     * @returns 向量
-     */ _proto.subtractVectors = function subtractVectors(left, right) {
-        this.x = left.x - right.x;
-        this.y = left.y - right.y;
-        this.z = left.z - right.z;
-        this.w = left.w - right.w;
-        return this;
+    _proto.setFloat = function setFloat(name, value) {
+        this.setControlParameterValue(name, value);
     };
-    /**
-     * 向量相乘
-     * @param right - 相乘对象，对象 | 数字
-     * @returns 向量
-     */ _proto.multiply = function multiply(right) {
-        if (typeof right === "number") {
-            this.x *= right;
-            this.y *= right;
-            this.z *= right;
-            this.w *= right;
-        } else if (_instanceof1(right, Array)) {
-            this.x *= right[0];
-            this.y *= right[1];
-            this.z *= right[2];
-            this.w *= right[3];
-        } else {
-            this.x *= right.x;
-            this.y *= right.y;
-            this.z *= right.z;
-            this.w *= right.w;
-        }
-        return this;
+    _proto.setTrigger = function setTrigger(name) {
+        this.setControlParameterValue(name, true);
     };
-    /**
-     * 向量相乘
-     * @param left - 向量
-     * @param right - 向量
-     * @returns 向量
-     */ _proto.multiplyVectors = function multiplyVectors(left, right) {
-        this.x = left.x * right.x;
-        this.y = left.y * right.y;
-        this.z = left.z * right.z;
-        this.w = left.w * right.w;
-        return this;
+    _proto.resetTrigger = function resetTrigger(name) {
+        this.setControlParameterValue(name, false);
     };
-    /**
-     * 向量相除
-     * @param right - 相除对象，对象 | 数字
-     * @returns 向量
-     */ _proto.divide = function divide(right) {
-        if (typeof right === "number") {
-            this.x /= right;
-            this.y /= right;
-            this.z /= right;
-            this.w /= right;
-        } else if (_instanceof1(right, Array)) {
-            this.x /= right[0];
-            this.y /= right[1];
-            this.z /= right[2];
-            this.w /= right[3];
-        } else {
-            this.x /= right.x;
-            this.y /= right.y;
-            this.z /= right.z;
-            this.w /= right.w;
-        }
-        return this;
+    // Debug Information
+    //-------------------------------------------------------------------------
+    _proto.getPoseNodeDebugInfo = function getPoseNodeDebugInfo(nodeIdx) {
+        var node = this.nodes[nodeIdx];
+        return node.getDebugInfo();
     };
-    /**
-     * 向量缩放
-     * @param v - 数字
-     * @returns 缩放结果
-     */ _proto.scale = function scale(v) {
-        this.x *= v;
-        this.y *= v;
-        this.z *= v;
-        this.w *= v;
-        return this;
+    _proto.getRuntimeNodeDebugValue = function getRuntimeNodeDebugValue(nodeIdx) {
+        var valueNode = this.nodes[nodeIdx];
+        return valueNode.getValue(this.context);
     };
-    /**
-     * 分量求和
-     * @returns 求和结果
-     */ _proto.sum = function sum() {
-        return this.x + this.y + this.z + this.w;
+    _proto.getNodeDebugInstance = function getNodeDebugInstance(nodeIdx) {
+        return this.nodes[nodeIdx];
     };
-    /**
-     * 向量求最小值
-     * @param v - 向量或数值
-     * @returns 最小值
-     */ _proto.min = function min(v) {
-        if (typeof v === "number") {
-            this.x = Math.min(this.x, v);
-            this.y = Math.min(this.y, v);
-            this.z = Math.min(this.z, v);
-            this.w = Math.min(this.w, v);
-        } else {
-            this.x = Math.min(this.x, v.x);
-            this.y = Math.min(this.y, v.y);
-            this.z = Math.min(this.z, v.z);
-            this.w = Math.min(this.w, v.w);
-        }
-        return this;
+    _proto.isControlParameter = function isControlParameter(nodeIdx) {
+        return nodeIdx < this.getNumControlParameters();
     };
-    /**
-     * 向量求最大值
-     * @param v - 向量或数值
-     * @returns 最大值
-     */ _proto.max = function max(v) {
-        if (typeof v === "number") {
-            this.x = Math.max(this.x, v);
-            this.y = Math.max(this.y, v);
-            this.z = Math.max(this.z, v);
-            this.w = Math.max(this.w, v);
-        } else {
-            this.x = Math.max(this.x, v.x);
-            this.y = Math.max(this.y, v.y);
-            this.z = Math.max(this.z, v.z);
-            this.w = Math.max(this.w, v.w);
+    _proto.setControlParameterValue = function setControlParameterValue(name, value) {
+        var index = this.getControlParameterIndex(name);
+        if (index !== InvalidIndex) {
+            this.nodes[index].setValue(value);
         }
-        return this;
     };
+    return GraphInstance;
+}();
+
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+
+/**
+ * @since 2.0.0
+ */ var Component = /*#__PURE__*/ function(EffectsObject) {
+    _inherits(Component, EffectsObject);
+    function Component() {
+        var _this;
+        _this = EffectsObject.apply(this, arguments) || this;
+        _this.isAwakeCalled = false;
+        _this.isStartCalled = false;
+        _this.isEnableCalled = false;
+        _this._enabled = true;
+        return _this;
+    }
+    var _proto = Component.prototype;
     /**
-     * 向量阈值约束
-     * @param min - 最小值
-     * @param max - 最大值
-     * @returns 向量
-     */ _proto.clamp = function clamp(min, max) {
-        return this.max(min).min(max);
+   * 生命周期函数，初始化后调用，生命周期内只调用一次
+   */ _proto.onAwake = function onAwake() {
+    // OVERRIDE
     };
     /**
-     * 向量向下取整
-     * @returns 取整结果
-     */ _proto.floor = function floor() {
-        this.x = Math.floor(this.x);
-        this.y = Math.floor(this.y);
-        this.z = Math.floor(this.z);
-        this.w = Math.floor(this.w);
-        return this;
+   * 在 enabled 变为 true 时触发
+   */ _proto.onEnable = function onEnable() {
+    // OVERRIDE
     };
     /**
-     * 向量向上取整
-     * @returns 取整结果
-     */ _proto.ceil = function ceil() {
-        this.x = Math.ceil(this.x);
-        this.y = Math.ceil(this.y);
-        this.z = Math.ceil(this.z);
-        this.w = Math.ceil(this.w);
-        return this;
+   * 在 enabled 变为 false 时触发
+   */ _proto.onDisable = function onDisable() {
+    // OVERRIDE
     };
     /**
-     * 向量四舍五入
-     * @returns 求值结果
-     */ _proto.round = function round() {
-        this.x = Math.round(this.x);
-        this.y = Math.round(this.y);
-        this.z = Math.round(this.z);
-        this.w = Math.round(this.w);
-        return this;
+   * 生命周期函数，在第一次 update 前调用，生命周期内只调用一次
+   */ _proto.onStart = function onStart() {
+    // OVERRIDE
     };
     /**
-     * 向量取绝对值
-     * @returns 向量
-     */ _proto.abs = function abs() {
-        this.x = Math.abs(this.x);
-        this.y = Math.abs(this.y);
-        this.z = Math.abs(this.z);
-        this.w = Math.abs(this.w);
-        return this;
+   * 生命周期函数，每帧调用一次
+   */ _proto.onUpdate = function onUpdate(dt) {
+    // OVERRIDE
     };
     /**
-     * 向量取反
-     * @returns 取反结果
-     */ _proto.negate = function negate() {
-        this.x = -this.x;
-        this.y = -this.y;
-        this.z = -this.z;
-        this.w = -this.w;
-        return this;
+   * 生命周期函数，每帧调用一次，在 update 之后调用
+   */ _proto.onLateUpdate = function onLateUpdate(dt) {
+    // OVERRIDE
     };
     /**
-     * 向量长度平方
-     * @returns 长度平方
-     */ _proto.lengthSquared = function lengthSquared() {
-        return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
+   * 生命周期函数，在组件销毁时调用
+   */ _proto.onDestroy = function onDestroy() {
+    // OVERRIDE
     };
     /**
-     * 向量长度
-     * @returns 长度
-     */ _proto.length = function length() {
-        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+   * @internal
+   */ _proto.enable = function enable() {
+        if (this.item.composition) {
+            this.item.composition.sceneTicking.addComponent(this);
+            this.isEnableCalled = true;
+        }
+        this.onEnable();
     };
     /**
-     * 向量归一化
-     * @returns 归一化结果
-     */ _proto.normalize = function normalize() {
-        return this.divide(this.length() || 1);
+   * @internal
+   */ _proto.disable = function disable() {
+        this.onDisable();
+        if (this.item.composition) {
+            this.isEnableCalled = false;
+            this.item.composition.sceneTicking.removeComponent(this);
+        }
     };
-    /**
-     * 设置向量长度
-     * @param length - 长度
-     * @returns 向量
-     */ _proto.setLength = function setLength(length) {
-        return this.normalize().multiply(length);
+    _proto.setVFXItem = function setVFXItem(item) {
+        this.item = item;
+        if (item.isDuringPlay) {
+            if (!this.isAwakeCalled) {
+                this.onAwake();
+                this.isAwakeCalled = true;
+            }
+            if (item.isActive && this.enabled) {
+                this.start();
+                this.enable();
+            }
+        }
     };
-    /**
-     * 向量求线性插值
-     * @param v - 向量
-     * @param alpha - 插值比例
-     * @returns 插值结果
-     */ _proto.lerp = function lerp(v, alpha) {
-        this.x += (v.x - this.x) * alpha;
-        this.y += (v.y - this.y) * alpha;
-        this.z += (v.z - this.z) * alpha;
-        this.w += (v.w - this.w) * alpha;
-        return this;
+    _proto.fromData = function fromData(data) {
+        EffectsObject.prototype.fromData.call(this, data);
     };
-    /**
-     * 两向量求线性插值
-     * @param v1 - 第一个向量
-     * @param v2 - 第二个向量
-     * @param alpha - 插值比例
-     * @returns 插值结果
-     */ _proto.lerpVectors = function lerpVectors(v1, v2, alpha) {
-        this.x = v1.x + (v2.x - v1.x) * alpha;
-        this.y = v1.y + (v2.y - v1.y) * alpha;
-        this.z = v1.z + (v2.z - v1.z) * alpha;
-        this.w = v1.w + (v2.w - v1.w) * alpha;
-        return this;
+    _proto.dispose = function dispose() {
+        if (this.isEnableCalled) {
+            this.disable();
+        }
+        if (this.isAwakeCalled) {
+            this.isAwakeCalled = false;
+            this.onDestroy();
+        }
+        if (this.item) {
+            removeItem(this.item.components, this);
+        }
     };
-    /**
-     * 向量求点积
-     * @param v - 向量
-     * @returns 点积结果
-     */ _proto.dot = function dot(v) {
-        return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
+    _proto.start = function start() {
+        if (this.isStartCalled) {
+            return;
+        }
+        this.isStartCalled = true;
+        this.onStart();
     };
-    /**
-     * 向量判等
-     * @param v - 向量
-     * @returns 判等结果
-     */ _proto.equals = function equals(v) {
-        return v.x === this.x && v.y === this.y && v.z === this.z && v.w === this.w;
+    _create_class(Component, [
+        {
+            key: "transform",
+            get: /**
+   * 附加到的 VFXItem 对象 Transform 组件
+   */ function get() {
+                return this.item.transform;
+            }
+        },
+        {
+            key: "isActiveAndEnabled",
+            get: /**
+   * 组件是否可以更新，true 更新，false 不更新
+   */ function get() {
+                return this.item.isActive && this.enabled;
+            }
+        },
+        {
+            key: "enabled",
+            get: function get() {
+                return this._enabled;
+            },
+            set: function set(value) {
+                if (this.enabled !== value) {
+                    this._enabled = value;
+                    if (value) {
+                        if (this.isActiveAndEnabled) {
+                            this.enable();
+                            if (!this.isStartCalled) {
+                                this.onStart();
+                                this.isStartCalled = true;
+                            }
+                        }
+                    } else {
+                        if (this.isEnableCalled) {
+                            this.disable();
+                        }
+                    }
+                }
+            }
+        }
+    ]);
+    return Component;
+}(EffectsObject);
+__decorate([
+    serialize()
+], Component.prototype, "item", void 0);
+__decorate([
+    serialize()
+], Component.prototype, "_enabled", void 0);
+/**
+ * @since 2.0.0
+ * @deprecated 2.4.0 Please use Component instead
+ */ var Behaviour = /*#__PURE__*/ function(Component) {
+    _inherits(Behaviour, Component);
+    function Behaviour() {
+        return Component.apply(this, arguments);
+    }
+    var _proto = Behaviour.prototype;
+    _proto.setVFXItem = function setVFXItem(item) {
+        Component.prototype.setVFXItem.call(this, item);
     };
-    /**
-     * 是否零向量
-     * @returns 是否零向量
-     */ _proto.isZero = function isZero() {
-        var eps = NumberEpsilon;
-        var _this = this, x = _this.x, y = _this.y, z = _this.z, w = _this.w;
-        return Math.abs(x) <= eps && Math.abs(y) <= eps && Math.abs(z) <= eps && Math.abs(w) <= eps;
+    _proto.dispose = function dispose() {
+        Component.prototype.dispose.call(this);
     };
-    /**
-     * 向量转数组
-     * @returns 数组
-     */ _proto.toArray = function toArray() {
-        return [
-            this.x,
-            this.y,
-            this.z,
-            this.w
-        ];
+    return Behaviour;
+}(Component);
+
+exports.Animator = /*#__PURE__*/ function(Component) {
+    _inherits(Animator, Component);
+    function Animator() {
+        var _this;
+        _this = Component.apply(this, arguments) || this;
+        /**
+   * @internal
+   */ _this.graph = null;
+        _this.graphAsset = null;
+        return _this;
+    }
+    var _proto = Animator.prototype;
+    _proto.setBool = function setBool(name, value) {
+        if (this.graph) {
+            this.graph.setBool(name, value);
+        }
     };
-    _proto.toVector3 = function toVector3() {
-        return new Vector3(this.x, this.y, this.z);
+    _proto.setFloat = function setFloat(name, value) {
+        if (this.graph) {
+            this.graph.setFloat(name, value);
+        }
     };
-    _proto.fill = function fill(array, offset) {
-        if (offset === void 0) offset = 0;
-        array[offset] = this.x;
-        array[offset + 1] = this.y;
-        array[offset + 2] = this.z;
-        array[offset + 3] = this.w;
+    _proto.setTrigger = function setTrigger(name) {
+        if (this.graph) {
+            this.graph.setTrigger(name);
+        }
     };
-    /**
-     * 生成随机向量
-     * @returns 向量
-     */ _proto.random = function random() {
-        this.x = Math.random();
-        this.y = Math.random();
-        this.z = Math.random();
-        this.w = Math.random();
-        return this;
+    _proto.resetTrigger = function resetTrigger(name) {
+        if (this.graph) {
+            this.graph.resetTrigger(name);
+        }
     };
-    /**
-     * 变换矩阵作用于向量
-     * @param m - 变换矩阵
-     * @param [out] - 输出结果，如果没有设置就直接覆盖当前值
-     * @returns 向量
-     */ _proto.applyMatrix = function applyMatrix(m, out) {
-        return m.transformVector4(this, out);
+    _proto.onStart = function onStart() {
+        if (this.graphAsset) {
+            this.graph = new GraphInstance(this.graphAsset, this.item);
+        }
     };
-    /**
-     * 通过标量数值创建向量
-     * @param num - 数值
-     * @returns 向量
-     */ Vector4.fromNumber = function fromNumber(num) {
-        return new Vector4().setFromNumber(num);
+    _proto.onUpdate = function onUpdate(dt) {
+        if (!this.graph) {
+            return;
+        }
+        var result = this.graph.evaluateGraph(dt / 1000);
+        // Apply transform animation
+        //-------------------------------------------------------------------------
+        var animatedTransforms = this.graph.skeleton.animatedTransforms;
+        for(var i = 0; i < animatedTransforms.length; i++){
+            var position = result.pose.parentSpaceTransforms[i].position;
+            var rotation = result.pose.parentSpaceTransforms[i].rotation;
+            var scale = result.pose.parentSpaceTransforms[i].scale;
+            var euler = result.pose.parentSpaceTransforms[i].euler;
+            animatedTransforms[i].setPosition(position.x, position.y, position.z);
+            animatedTransforms[i].setScale(scale.x, scale.y, scale.z);
+            if (this.graph.skeleton.useEuler) {
+                animatedTransforms[i].setRotation(euler.x, euler.y, euler.z);
+            } else {
+                animatedTransforms[i].setQuaternion(rotation.x, rotation.y, rotation.z, rotation.w);
+            }
+        }
+        // Apply property animation
+        //-------------------------------------------------------------------------
+        var floatAnimatedObjects = this.graph.skeleton.floatAnimatedObjects;
+        for(var i1 = 0; i1 < floatAnimatedObjects.length; i1++){
+            var animatedObject = floatAnimatedObjects[i1];
+            var property = animatedObject.property;
+            animatedObject.target[property] = result.pose.floatPropertyValues[i1];
+        }
+        var colorAnimatedObjects = this.graph.skeleton.colorAnimatedObjects;
+        for(var i2 = 0; i2 < colorAnimatedObjects.length; i2++){
+            var animatedObject1 = colorAnimatedObjects[i2];
+            var property1 = animatedObject1.property;
+            animatedObject1.target[property1] = result.pose.colorPropertyValues[i2];
+        }
     };
-    /**
-     * 通过数组创建向量
-     * @param array - 数组
-     * @param [offset=0] - 起始偏移值
-     * @returns 向量
-     */ Vector4.fromArray = function fromArray(array, offset) {
-        if (offset === void 0) offset = 0;
-        return new Vector4().setFromArray(array, offset);
+    _proto.fromData = function fromData(data) {
+        this.graphAsset = this.engine.findObject(data.graphAsset);
     };
-    return Vector4;
-}();
+    return Animator;
+}(Component);
+exports.Animator = __decorate([
+    effectsClass("Animator")
+], exports.Animator);
+
 /**
-     * 四维向量的常量
-     */ Vector4.ONE = new Vector4(1.0, 1.0, 1.0, 1.0);
-Vector4.ZERO = new Vector4(0.0, 0.0, 0.0, 0.0);
+ * 所有渲染组件的基类
+ * @since 2.0.0
+ */ var RendererComponent = /*#__PURE__*/ function(Component) {
+    _inherits(RendererComponent, Component);
+    function RendererComponent() {
+        var _this;
+        _this = Component.apply(this, arguments) || this;
+        _this.materials = [];
+        _this._priority = 0;
+        return _this;
+    }
+    var _proto = RendererComponent.prototype;
+    _proto.render = function render(renderer) {};
+    _proto.onEnable = function onEnable() {
+        var _this_item_composition;
+        (_this_item_composition = this.item.composition) == null ? void 0 : _this_item_composition.renderFrame.addMeshToDefaultRenderPass(this);
+    };
+    _proto.onDisable = function onDisable() {
+        var _this_item_composition;
+        (_this_item_composition = this.item.composition) == null ? void 0 : _this_item_composition.renderFrame.removeMeshFromDefaultRenderPass(this);
+    };
+    _create_class(RendererComponent, [
+        {
+            key: "priority",
+            get: function get() {
+                return this._priority;
+            },
+            set: function set(value) {
+                this._priority = value;
+            }
+        },
+        {
+            key: "material",
+            get: function get() {
+                return this.materials[0];
+            },
+            set: function set(material) {
+                if (this.materials.length === 0) {
+                    this.materials.push(material);
+                } else {
+                    this.materials[0] = material;
+                }
+            }
+        }
+    ]);
+    return RendererComponent;
+}(Component);
+__decorate([
+    serialize()
+], RendererComponent.prototype, "materials", void 0);
+__decorate([
+    serialize()
+], RendererComponent.prototype, "_priority", void 0);
 
 /**
  * Mesh 组件
@@ -6781,516 +7291,6 @@ exports.PostProcessVolume = __decorate([
     effectsClass(DataType.PostProcessVolume)
 ], exports.PostProcessVolume);
 
-var Color = /*#__PURE__*/ function() {
-    function Color(r, g, b, a) {
-        if (r === void 0) r = 0;
-        if (g === void 0) g = 0;
-        if (b === void 0) b = 0;
-        if (a === void 0) a = 0;
-        this.r = r;
-        this.g = g;
-        this.b = b;
-        this.a = a;
-    }
-    var _proto = Color.prototype;
-    /**
-     * 设置颜色
-     * @param r - r 分量
-     * @param g - g 分量
-     * @param b - b 分量
-     * @param a - a 分量
-     * @returns
-     */ _proto.set = function set(r, g, b, a) {
-        this.r = r;
-        this.g = g;
-        this.b = b;
-        this.a = a;
-        return this;
-    };
-    /**
-     * 设置零颜色
-     * @returns
-     */ _proto.setZero = function setZero() {
-        this.r = 0;
-        this.g = 0;
-        this.b = 0;
-        this.a = 0;
-        return this;
-    };
-    /**
-     * 通过标量数值设置颜色
-     * @param num - 数值
-     * @returns
-     */ _proto.setFromNumber = function setFromNumber(num) {
-        this.r = num;
-        this.g = num;
-        this.b = num;
-        this.a = num;
-        return this;
-    };
-    /**
-     * 通过Vector4创建颜色
-     * @param v - Vector4
-     * @returns
-     */ _proto.setFromVector4 = function setFromVector4(v) {
-        this.r = v.x;
-        this.g = v.y;
-        this.b = v.z;
-        this.a = v.w;
-        return this;
-    };
-    /**
-     * 通过数组创建颜色
-     * @param array - 数组
-     * @param [offset=0] - 起始偏移值
-     * @returns
-     */ _proto.setFromArray = function setFromArray(array, offset) {
-        if (offset === void 0) offset = 0;
-        var _array_offset;
-        this.r = (_array_offset = array[offset]) != null ? _array_offset : 0;
-        var _array_;
-        this.g = (_array_ = array[offset + 1]) != null ? _array_ : 0;
-        var _array_1;
-        this.b = (_array_1 = array[offset + 2]) != null ? _array_1 : 0;
-        var _array_2;
-        this.a = (_array_2 = array[offset + 3]) != null ? _array_2 : 0;
-        return this;
-    };
-    _proto.setFromHSV = function setFromHSV(hue, saturation, value, alpha) {
-        if (alpha === void 0) alpha = 1;
-        var chroma = value * saturation;
-        var h = hue / 60;
-        var x = chroma * (1 - Math.abs(h % 2 - 1));
-        var r = 0;
-        var g = 0;
-        var b = 0;
-        if (h >= 0 && h <= 1) {
-            r = chroma;
-            g = x;
-        } else if (h >= 1 && h <= 2) {
-            r = x;
-            g = chroma;
-        } else if (h >= 2 && h <= 3) {
-            g = chroma;
-            b = x;
-        } else if (h >= 3 && h <= 4) {
-            g = x;
-            b = chroma;
-        } else if (h >= 4 && h <= 5) {
-            r = x;
-            b = chroma;
-        } else if (h >= 5 && h <= 6) {
-            r = chroma;
-            b = x;
-        }
-        var m = value - chroma;
-        return this.set(r + m, g + m, b + m, alpha);
-    };
-    _proto.setFromHexString = function setFromHexString(hex) {
-        if (hex.substring(0, 1) !== "#" || hex.length !== 9 && hex.length !== 7) {
-            return this;
-        }
-        var r = parseInt(hex.substring(1, 3), 16) / 255.0;
-        var g = parseInt(hex.substring(3, 5), 16) / 255.0;
-        var b = parseInt(hex.substring(5, 7), 16) / 255.0;
-        var a = hex.length === 9 ? parseInt(hex.substring(7, 9), 16) / 255.0 : 1.0;
-        return this.set(r, g, b, a);
-    };
-    /**
-     * 拷贝颜色
-     * @param v - 复制对象
-     * @returns 拷贝结果
-     */ _proto.copyFrom = function copyFrom(v) {
-        this.r = v.r;
-        this.g = v.g;
-        this.b = v.b;
-        this.a = v.a;
-        return this;
-    };
-    /**
-     * 克隆颜色
-     * @returns 克隆结果
-     */ _proto.clone = function clone() {
-        return new Color(this.r, this.g, this.b, this.a);
-    };
-    /**
-     * 根据下标设置颜色分量
-     * @param index - 下标值
-     * @param value - 分量值
-     * @returns
-     */ _proto.setElement = function setElement(index, value) {
-        switch(index){
-            case 0:
-                this.r = value;
-                break;
-            case 1:
-                this.g = value;
-                break;
-            case 2:
-                this.b = value;
-                break;
-            case 3:
-                this.a = value;
-                break;
-            default:
-                console.error("index is out of range: " + index);
-        }
-        return this;
-    };
-    /**
-     * 根据下标获取颜色分量
-     * @param index - 下标
-     * @returns 分量值
-     */ _proto.getElement = function getElement(index) {
-        switch(index){
-            case 0:
-                return this.r;
-            case 1:
-                return this.g;
-            case 2:
-                return this.b;
-            case 3:
-                return this.a;
-            default:
-                console.error("index is out of range: " + index);
-        }
-        return 0;
-    };
-    /**
-     * 颜色相加
-     * @param right - 相加对象，颜色 | 数字
-     * @returns 相加结果
-     */ _proto.add = function add(right) {
-        if (typeof right === "number") {
-            this.r += right;
-            this.g += right;
-            this.b += right;
-            this.a += right;
-        } else if (_instanceof1(right, Array)) {
-            this.r += right[0];
-            this.g += right[1];
-            this.b += right[2];
-            this.a += right[3];
-        } else {
-            this.r += right.r;
-            this.g += right.g;
-            this.b += right.b;
-            this.a += right.a;
-        }
-        return this;
-    };
-    /**
-     * 颜色相减
-     * @param right - 相减对象，颜色 | 数字
-     * @returns 相减结果
-     */ _proto.subtract = function subtract(right) {
-        if (typeof right === "number") {
-            this.r -= right;
-            this.g -= right;
-            this.b -= right;
-            this.a -= right;
-        } else if (_instanceof1(right, Array)) {
-            this.r -= right[0];
-            this.g -= right[1];
-            this.b -= right[2];
-            this.a -= right[3];
-        } else {
-            this.r -= right.r;
-            this.g -= right.g;
-            this.b -= right.b;
-            this.a -= right.a;
-        }
-        return this;
-    };
-    /**
-     * 颜色相乘
-     * @param right - 相乘对象，对象 | 数字
-     * @returns 颜色
-     */ _proto.multiply = function multiply(right) {
-        if (typeof right === "number") {
-            this.r *= right;
-            this.g *= right;
-            this.b *= right;
-            this.a *= right;
-        } else if (_instanceof1(right, Array)) {
-            this.r *= right[0];
-            this.g *= right[1];
-            this.b *= right[2];
-            this.a *= right[3];
-        } else {
-            this.r *= right.r;
-            this.g *= right.g;
-            this.b *= right.b;
-            this.a *= right.a;
-        }
-        return this;
-    };
-    /**
-     * 颜色相除
-     * @param right - 相除对象，对象 | 数字
-     * @returns 颜色
-     */ _proto.divide = function divide(right) {
-        if (typeof right === "number") {
-            this.r /= right;
-            this.g /= right;
-            this.b /= right;
-            this.a /= right;
-        } else if (_instanceof1(right, Array)) {
-            this.r /= right[0];
-            this.g /= right[1];
-            this.b /= right[2];
-            this.a /= right[3];
-        } else {
-            this.r /= right.r;
-            this.g /= right.g;
-            this.b /= right.b;
-            this.a /= right.a;
-        }
-        return this;
-    };
-    /**
-     * 颜色缩放
-     * @param v - 数字
-     * @returns 缩放结果
-     */ _proto.scale = function scale(v) {
-        this.r *= v;
-        this.g *= v;
-        this.b *= v;
-        this.a *= v;
-        return this;
-    };
-    /**
-     * 颜色求最小值
-     * @param v - 颜色或数值
-     * @returns 最小值
-     */ _proto.min = function min(v) {
-        if (typeof v === "number") {
-            this.r = Math.min(this.r, v);
-            this.g = Math.min(this.g, v);
-            this.b = Math.min(this.b, v);
-            this.a = Math.min(this.a, v);
-        } else {
-            this.r = Math.min(this.r, v.r);
-            this.g = Math.min(this.g, v.g);
-            this.b = Math.min(this.b, v.b);
-            this.a = Math.min(this.a, v.a);
-        }
-        return this;
-    };
-    /**
-     * 颜色求最大值
-     * @param v - 颜色或数值
-     * @returns 最大值
-     */ _proto.max = function max(v) {
-        if (typeof v === "number") {
-            this.r = Math.max(this.r, v);
-            this.g = Math.max(this.g, v);
-            this.b = Math.max(this.b, v);
-            this.a = Math.max(this.a, v);
-        } else {
-            this.r = Math.max(this.r, v.r);
-            this.g = Math.max(this.g, v.g);
-            this.b = Math.max(this.b, v.b);
-            this.a = Math.max(this.a, v.a);
-        }
-        return this;
-    };
-    /**
-     * 颜色阈值约束
-     * @param min - 最小值
-     * @param max - 最大值
-     * @returns 颜色
-     */ _proto.clamp = function clamp(min, max) {
-        return this.max(min).min(max);
-    };
-    /**
-     * 颜色求线性插值
-     * @param v - 颜色
-     * @param alpha - 插值比例
-     * @returns 插值结果
-     */ _proto.lerp = function lerp(v, alpha) {
-        this.r += (v.r - this.r) * alpha;
-        this.g += (v.g - this.g) * alpha;
-        this.b += (v.b - this.b) * alpha;
-        this.a += (v.a - this.a) * alpha;
-        return this;
-    };
-    /**
-     * 计算颜色亮度值
-     * @returns 亮度值
-     */ _proto.luminance = function luminance() {
-        return this.r * 0.3 + this.g * 0.59 + this.b * 0.11;
-    };
-    /**
-     * 颜色判等
-     * @param v - 颜色
-     * @returns 判等结果
-     */ _proto.equals = function equals(v) {
-        return v.r === this.r && v.g === this.g && v.b === this.b && v.a === this.a;
-    };
-    _proto.toLinear = function toLinear() {
-        this.r = Color.gammaToLinear(this.r);
-        this.g = Color.gammaToLinear(this.g);
-        this.b = Color.gammaToLinear(this.b);
-        return this;
-    };
-    _proto.toGamma = function toGamma() {
-        this.r = Color.linearToGamma(this.r);
-        this.g = Color.linearToGamma(this.g);
-        this.b = Color.linearToGamma(this.b);
-        return this;
-    };
-    /**
-     * 颜色转数组
-     * @returns 数组
-     */ _proto.toArray = function toArray() {
-        return [
-            this.r,
-            this.g,
-            this.b,
-            this.a
-        ];
-    };
-    _proto.toVector4 = function toVector4() {
-        return new Vector4(this.r, this.g, this.b, this.a);
-    };
-    /**
-     * RGB 颜色空间转 HSV
-     * @param result HSV 值
-     */ _proto.toHSV = function toHSV() {
-        var _this = this, r = _this.r, g = _this.g, b = _this.b, a = _this.a;
-        var max = Math.max(r, g, b);
-        var min = Math.min(r, g, b);
-        var v = max;
-        var dm = max - min;
-        var h = 0;
-        var s = 0;
-        if (max !== 0) {
-            s = dm / max;
-        }
-        if (max != min) {
-            if (max == r) {
-                h = (g - b) / dm;
-                if (g < b) {
-                    h += 6;
-                }
-            } else if (max == g) {
-                h = (b - r) / dm + 2;
-            } else if (max == b) {
-                h = (r - g) / dm + 4;
-            }
-            h *= 60;
-        }
-        return new Color(h, s, v, a);
-    };
-    _proto.toHexString = function toHexString(includeAlpha) {
-        if (includeAlpha === void 0) includeAlpha = true;
-        var R = Color.ToHex(Math.round(this.r * 255));
-        var G = Color.ToHex(Math.round(this.g * 255));
-        var B = Color.ToHex(Math.round(this.b * 255));
-        var A = Color.ToHex(Math.round(this.a * 255));
-        if (includeAlpha) {
-            return "#" + R + G + B + A;
-        } else {
-            return "#" + R + G + B;
-        }
-    };
-    _proto.fill = function fill(array, offset) {
-        if (offset === void 0) offset = 0;
-        array[offset] = this.r;
-        array[offset + 1] = this.g;
-        array[offset + 2] = this.b;
-        array[offset + 3] = this.a;
-    };
-    /**
-     * 通过标量数值创建颜色
-     * @param num - 数值
-     * @returns
-     */ Color.fromNumber = function fromNumber(num) {
-        return new Color().setFromNumber(num);
-    };
-    /**
-     * 通过数组创建颜色
-     * @param array - 数组
-     * @param [offset=0] - 起始偏移值
-     * @returns
-     */ Color.fromArray = function fromArray(array, offset) {
-        if (offset === void 0) offset = 0;
-        return new Color().setFromArray(array, offset);
-    };
-    /**
-     * 通过 hex 字符串创建颜色
-     * @param hex - hex 字符串
-     * @returns
-     */ Color.fromHexString = function fromHexString(hex) {
-        return new Color().setFromHexString(hex);
-    };
-    Color.fromHSV = function fromHSV(hue, saturation, value, alpha) {
-        if (alpha === void 0) alpha = 1;
-        return new Color().setFromHSV(hue, saturation, value, alpha);
-    };
-    /**
-     * 颜色值从 Gamma 空间转到线性空间
-     * @param v - Gamma 空间颜色值
-     * @returns 线性空间颜色值
-     */ Color.gammaToLinear = function gammaToLinear(v) {
-        if (v <= 0.0) {
-            return 0.0;
-        } else if (v <= 0.04045) {
-            return v / 12.92;
-        } else if (v < 1.0) {
-            return Math.pow((v + 0.055) / 1.055, 2.4);
-        } else {
-            return Math.pow(v, 2.4);
-        }
-    };
-    /**
-     * 颜色值从线性空间转到 Gamma 空间
-     * @param value - 线性空间颜色值
-     * @returns Gamma 空间颜色值
-     */ Color.linearToGamma = function linearToGamma(value) {
-        if (value <= 0.0) {
-            return 0.0;
-        } else if (value < 0.0031308) {
-            return 12.92 * value;
-        } else if (value < 1.0) {
-            return 1.055 * Math.pow(value, 0.41666) - 0.055;
-        } else {
-            return Math.pow(value, 0.41666);
-        }
-    };
-    Color.ToHex = function ToHex(i) {
-        var str = i.toString(16);
-        if (i <= 15) {
-            return ("0" + str).toUpperCase();
-        }
-        return str.toUpperCase();
-    };
-    return Color;
-}();
-/**
-     * 颜色的常量
-     */ Color.BLACK = new Color(0, 0, 0, 1) // 纯黑色
-;
-Color.BLUE = new Color(0, 0, 1, 1) // 纯蓝色
-;
-Color.CLEAR = new Color(0, 0, 0, 0) // 完全透明
-;
-Color.CYAN = new Color(0, 1, 1, 1) // 青色
-;
-Color.GRAY = new Color(0.5, 0.5, 0.5, 1) // 灰色
-;
-Color.GREEN = new Color(0, 1, 0, 1) // 纯绿色
-;
-Color.MAGENTA = new Color(1, 0, 1, 1) // 洋红色
-;
-Color.RED = new Color(1, 0, 0, 1) // 纯红色
-;
-Color.WHITE = new Color(1, 1, 1, 1) // 纯白色
-;
-Color.YELLOW = new Color(1, 0.92, 0.016, 1) // 黄色
-;
-
 /**
  * 四阶矩阵（列优先矩阵）
  */ var Matrix4 = /*#__PURE__*/ function() {
@@ -24301,7 +24301,7 @@ var LateUpdateTickData = /*#__PURE__*/ function(TickData) {
         return (_this_renderer = this.renderer) == null ? void 0 : _this_renderer.engine;
     };
     /**
-   * Item 求交测试，返回求交结果列表，x 和 y 是归一化到[-1, 1]区间的值，原点在左上角
+   * Item 求交测试，返回求交结果列表，x 和 y 是归一化到[-1, 1]区间的值，x 向右，y 向上
    * @param x - 鼠标或触点的 x，已经归一化到[-1, 1]
    * @param y - 鼠标或触点的 y，已经归一化到[-1, 1]
    * @param force - 是否强制求交，没有交互信息的 Item 也要进行求交测试
@@ -31147,7 +31147,7 @@ function getStandardSpriteContent(sprite, transform) {
     return ret;
 }
 
-var version$1 = "2.6.7";
+var version$1 = "2.6.8";
 var v0 = /^(\d+)\.(\d+)\.(\d+)(-(\w+)\.\d+)?$/;
 var standardVersion = /^(\d+)\.(\d+)$/;
 var reverseParticle = false;
@@ -34401,7 +34401,7 @@ registerPlugin("sprite", SpriteLoader, exports.VFXItem);
 registerPlugin("particle", ParticleLoader, exports.VFXItem);
 registerPlugin("cal", CalculateLoader, exports.VFXItem);
 registerPlugin("interact", InteractLoader, exports.VFXItem);
-var version = "2.6.7";
+var version = "2.6.8";
 logger.info("Core version: " + version + ".");
 
 exports.AbstractPlugin = AbstractPlugin;