three Vector4 四维向量

在 Three.js 中，Vector4 表示四维向量，常用于存储齐次坐标、颜色或其他四个分量的数据。其分量为 x, y, z（空间坐标或颜色值）和 w（用于齐次坐标、透明度或时间等）。

Vector4 有七个属性四十七个方法

属性

• isVector4 : Boolean 判断是四维向量
• x : Float x 分量
• y : Float y 分量
• z : Float z 分量
• w : Float w 分量
• width : Float z 别名
• height : Float w 别名

方法

• add ( v : Vector4 ) : this 将传入的向量v和这个向量相加。

    const v1 = new THREE.Vector4(1, 2, 3, 4);applyMatrix4 ( m : Matrix4 ) : this
    
    const v2 = new THREE.Vector4(5, 6, 7, 8);
    v1.add(v2);  // v1 的新值为 (6, 8, 10, 12)
    console.log(v1);  // 输出: Vector4 {x: 6, y: 8, z: 10, w: 12}

• addScalar ( s : Float ) : this 将传入的标量s和这个向量的x值、y值、z值以及w值相加。
• addScaledVector ( v : Vector4, s : Float ) : this 将所传入的v与s相乘所得的乘积和这个向量相加。

    const v1 = new THREE.Vector4(1, 2, 3, 4);
    const v2 = new THREE.Vector4(5, 6, 7, 8);
    const scale = 2;
    v1.addScaledVector(v2, scale);  // v2 的每个分量被乘以 2 后加到 v1
    console.log(v1);  // 输出: Vector4 {x: 11, y: 14, z: 17, w: 20}

• addVectors ( a : Vector4, b : Vector4 ) : this 将该向量设置为a + b
• applyMatrix4 ( m : Matrix4 ) : this 是 Three.js 中 Vector4 类的一个方法，用于将 Matrix4 矩阵应用于当前向量 Vector4，并更新当前向量的值。此操作通常用于在 3D 空间中对向量进行变换，比如旋转、缩放或平移。

    const v = new THREE.Vector4(1, 0, 2, 1);  // 齐次坐标 (x, y, z, w)
    const matrix = new THREE.Matrix4().makeRotationX(Math.PI / 4);  // 创建绕 X 轴旋转的矩阵
    v.applyMatrix4(matrix);  // 将旋转矩阵应用于向量 v
    console.log(v);  // 输出: 更新后的向量值 { "x": 1, "y": -1.414213562373095, "z": 1.4142135623730951, "w": 1 }

• ceil () : this 将该向量x分量、 y分量z分量以及w分量向上取整为最接近的整数。
• clamp ( min : Vector4, max : Vector4 ) : this min - 在限制范围内，x值、y值、z值以及w值的最小值 max - 在限制范围内，x值、y值、z值以及w值的最大值 如果该向量的x值、y值、z值或w值大于限制范围内最大x值、y值、z值或w值，则该值将会被所对应的值取代。 如果该向量的x值、y值、z值或w值小于限制范围内最小x值、y值、z值或w值，则该值将会被所对应的值取代。
• clampLength ( min : Float, max : Float ) : this min - 长度将被限制为的最小值 max - 长度将被限制为的最大值 如果向量长度大于最大值，则它将会被最大值所取代。 如果向量长度小于最小值，则它将会被最小值所取代。

    // 创建一个 Vector4 向量
    const v = new THREE.Vector4(3, 4, 0, 1); // 这个向量的长度是 5
    // 限制向量的长度在 2 到 4 之间
    v.clampLength(2, 4);
    console.log(v); // 输出: { "x": 2.3533936216582085, "y": 3.1378581622109447, "z": 0, "w": 0.7844645405527362 }

• clampScalar ( min : Float, max : Float ) : this min - 分量将被限制为的最小值 max - 分量将被限制为的最大值 如果该向量的x值、y值、z值或w值大于最大值，则它们将被最大值所取代。 如果该向量的x值、y值、z值或w值小于最小值，则它们将被最小值所取代。
• clone () : Vector4 返回一个新的Vector4，其具有和当前这个向量相同的x、y、z和w。
• copy ( v : Vector4 ) : this 将所传入Vector4的x、y、z和w属性复制给这一Vector4。
• divideScalar ( s : Float ) : this 将该向量除以标量s。

    // 创建一个 Vector4 向量
    const v = new THREE.Vector4(4, 8, 12, 16); // 原始向量
    // 将向量的每个分量都除以 4
    v.divideScalar(4);
    console.log(v); // 输出: { x: 1, y: 2, z: 3, w: 4 }

• dot ( v : Vector4 ) : Float 计算该vector和所传入v 的点积（dot product）。

    // 创建两个 Vector4 向量
    const v1 = new THREE.Vector4(1, 2, 3, 4);
    const v2 = new THREE.Vector4(5, 6, 7, 8);
    // 计算点积
    const dotProduct = v1.dot(v2);
    console.log(dotProduct); // 输出: 70

• equals ( v : Vector4 ) : Boolean 检查该向量和v的严格相等性。
• floor () : this 向量的分量向下取整为最接近的整数值。
• fromArray ( array : Array, offset : Integer ) : this array - 来源矩阵。 offset - （可选）在数组中的元素偏移量，默认值为0。 设置向量中的x值为array[ offset + 0 ]，y值为array[ offset + 1 ]， z值为array[ offset + 2 ]，w 值为array[ offset + 3 ]。
• fromBufferAttribute ( attribute : BufferAttribute, index : Integer ) : this attribute - 来源的attribute。 index - 在attribute中的索引。 从attribute中设置向量的x值、y值、z值和w值。
• getComponent ( index : Integer ) : Float index - 0, 1, 2 or 3. 如果index值为0返回x值。 如果index值为1返回y值。 如果index值为2返回z值。 如果index值为3返回w值。
• length () : Float 计算从(0, 0, 0, 0) 到 (x, y, z, w)的欧几里得长度 （Euclidean length，即直线长度）。

    // 创建一个 Vector4 向量
    const v = new THREE.Vector4(3, 4, 12, 16);
    // 计算向量的长度
    const len = v.length();
    console.log(len); // 输出: 19.4164878389476

• manhattanLength () : Float 计算该向量的曼哈顿长度（Manhattan length）。

    // 创建一个 Vector4 向量
    const v = new THREE.Vector4(3, -4, 12, -16);
    // 计算曼哈顿长度
    const manhattanLen = v.manhattanLength();
    console.log(manhattanLen); // 输出: 35

• lengthSq () : Float 计算从(0, 0, 0, 0)到(x, y, z, w)的欧几里得长度 （Euclidean length，即直线长度）的平方。 如果你正在比较向量的长度，应当比较的是长度的平方，因为它的计算效率更高一些。就是length 不开方的值
• lerp ( v : Vector4, alpha : Float ) : this v - 朝着进行插值的Vector4。 alpha - 插值因数，其范围通常在[0, 1]闭区间。 在该向量与传入的向量v之间的线性插值，alpha是沿着线的长度的百分比 —— alpha = 0 时表示的是当前向量，alpha = 1 时表示的是所传入的向量v。
• lerpVectors ( v1 : Vector4, v2 : Vector4, alpha : Float ) : this v1 - 起始的Vector4。 v2 - 朝着进行插值的Vector4。 alpha - 插值因数，其范围在[0, 1]闭区间。 将此向量设置为在v1和v2之间进行线性插值的向量， 其中alpha为两个向量之间连线的长度的百分比 —— alpha = 0 时表示的是v1，alpha = 1 时表示的是v2。
• negate () : this 向量取反，即： x = -x, y = -y, z = -z , w = -w。
• normalize () : this 在 Three.js 中，Vector4 的 normalize() 方法用于将向量归一化，即将其长度缩放为 1，同时保留向量的方向。归一化后的向量称为单位向量。

    // 创建一个 Vector4 向量
    const v = new THREE.Vector4(3, 4, 12, 16);
    // 归一化向量
    v.normalize();
    console.log(v); // 输出:  { "x": 0.1455213750217998, "y": 0.19402850002906638, "z": 0.5820855000871992, "w": 0.7761140001162655 }

• max ( v : Vector4 ) : this 如果该向量的x值、y值、z值或w值小于所传入v的x值、y值、z值或w值， 则将该值替换为对应的最大值。
• min ( v : Vector4 ) : this 如果该向量的x值、y值、z值或w值大于所传入v的x值、y值、z值或w值， 则将该值替换为对应的最小值。
• multiply ( v : Vector4 ) : this 将该向量与所传入的向量v进行相乘。

    // 创建两个 Vector4 向量
    const v1 = new THREE.Vector4(1, 2, 3, 4);
    const v2 = new THREE.Vector4(5, 6, 7, 8);
    // 逐元素相乘
    v1.multiply(v2);
    console.log(v1); // 输出: { x: 5, y: 12, z: 21, w: 32 }

• multiplyScalar ( s : Float ) : this 将该向量与所传入的标量s进行相乘。
• round () : this 向量中的分量四舍五入取整为最接近的整数值。
• roundToZero () : this 向量中的分量朝向0取整数（若分量为负数则向上取整，若为正数则向下取整）
• set ( x : Float, y : Float, z : Float, w : Float ) : this 设置该向量的x、y、z和w分量。
• setAxisAngleFromQuaternion ( q : Quaternion ) : this q - 归一化的Quaternion（四元数）

    // 创建一个 Quaternion 表示旋转
    const q = new THREE.Quaternion(0, 0, Math.sin(Math.PI / 4), Math.cos(Math.PI / 4)); // 旋转 90 度绕 Z 轴
    // 创建一个 Vector4 向量
    const v = new THREE.Vector4();
    // 从 Quaternion 设置轴角
    v.setAxisAngleFromQuaternion(q);
    console.log(v); // 输出: 旋转轴和角度 { "x": 0, "y": 0, "z": 1, "w": 1.5707963267948966 }

• setAxisAngleFromRotationMatrix ( m : Matrix4 ) : this m - 一个Matrix4（四阶矩阵），其左上角3x3的元素表示的是一个纯旋转矩。 将该向量的x、y和z设置为旋转轴，w为角度。

    // 创建一个旋转矩阵
    const rotationMatrix = new THREE.Matrix4();
    // 这里可以通过旋转、缩放等操作设置旋转矩阵
    rotationMatrix.makeRotationX(Math.PI / 4); // 例如：绕X轴旋转45度
    // 创建一个轴角向量
    const axisAngle = new THREE.Vector4(); // 或者可以用 THREE.Vector3
    // 使用 setAxisAngleFromRotationMatrix 方法
    axisAngle.setAxisAngleFromRotationMatrix(rotationMatrix);
    // axisAngle 现在包含了从旋转矩阵转换来的轴和角度
    console.log(axisAngle);// { "x": 1, "y": 0, "z": 0, "w": 0.7853981633974484 }

• setComponent ( index : Integer, value : Float ) : this index - 0、1、2 或 3。 value - Float 若index为 0 则设置 x 值为 value。 若index为 1 则设置 y 值为 value。 若index为 2 则设置 z 值为 value。 若index为 3 则设置 w 值为 value。
• setLength ( l : Float ) : this 将该向量的方向设置为和原向量相同，但是长度（length）为l。
• setScalar ( scalar : Float ) : this 将该向量的x、y、z值和w同时设置为等于传入的scalar。
• setX ( x : Float ) : this 将向量中的x值替换为x。
• setY ( y : Float ) : this 将向量中的y值替换为y。
• setZ ( z : Float ) : this 将向量中的z值替换为z。
• setW ( w : Float ) : this 将向量中的w值替换为w。
• sub ( v : Vector4 ) : this 从该向量减去向量v。
• subScalar ( s : Float ) : this 从该向量的x、y、z和w分量中减去标量s。
• subVectors ( a : Vector4, b : Vector4 ) : this 将该向量设置为a - b。
• toArray ( array : Array, offset : Integer ) : Array array - （可选）被用于存储向量的数组。如果这个值没有传入，则将创建一个新的数组。 offset - （可选） 数组中元素的偏移量。　返回一个数组[x, y, z, w]，或者将x、y、z和w复制到所传入的array中。
• random () : this 将该向量的每个分量(x、y、z、w)设置为介于 0 和 1 之间的伪随机数，不包括 1。