Crafty.math.Vector2D 类

Vector2D 使用方式如下:

public {Vector2D} Vector2D();

public {Vector2D} Vector2D(Vector2D);

public {Vector2D} Vector2D(Number, Number);

{Vector2D|Number=0} x

{Number=0} y

方法

Back to top

.add()

将传递的向量添加到这个向量

public {Vector2D} add(Vector2D);

{vector2D} vecRH

[Returns]: {Vector2D}是之后要添加的向量

Back to top

.angleBetween()

计算传递向量与这个向量之间的夹角，使用<0,0>作为参考点。返回的角度在这个范围 (−π, π].

public {Number} angleBetween(Vector2D);

{Vector2D} vecRH

[Returns]: {Number} 是两个向量的夹角

Back to top

.angleTo()

计算从这个向量得到传递向量的角度，用这个向量作为参考点。

public {Number} angleTo(Vector2D);

{Vector2D} vecRH

[Returns]: {Number} 两个向量的夹角弧度

Back to top

.clone()

创建并获取，这个矢量的数值拷贝

public {Vector2D} clone();

[Returns]: {Vector2D} 是新的向量

Back to top

.crossProduct()

计算两个向量的外积的z分量，这两个向量的积是三维的

public {Number} crossProduct(Vector2D);

{Vector2D} vecRH

[Returns]: {Number} 是合成的外积

Back to top

.distance()

计算从这个向量到传递向量的距离。

public {Number} distance(Vector2D);

{Vector2D} vecRH

[Returns]: {Number} 是两个向量间的距离

Back to top

.distanceSq()

计算从这个向量到传递向量的平方距离。这个函数避免计算平方根，因此比 .distance( ) 略快。

public {Number} distanceSq(Vector2D);

{Vector2D} vecRH

[Returns]: {Number} 两个矢量之间距离的平方

参见

.distance

Back to top

.divide()

将这个向量除以传递的向量。

public {Vector2D} divide(Vector2D);

{Vector2D} vecRH

[Returns]: {Vector2D} 被除后的向量

Back to top

.dotProduct()

计算这个和经过的向量的点积

public {Number} dotProduct(Vector2D);

{Vector2D} vecRH

[Returns]: {Number} 为最终的点积

Back to top

.equals()

确定这个向量在数值上与传递的向量是否等价。

public {Boolean} equals(Vector2D);

{Vector2D} vecRH

[Returns]: {Boolean} true 如果两个向量相等

Back to top

.getNormal()

计算一个新的右向单位向量，它垂直于由这个和传递的向量所创建的直线。

public {Vector2D} getNormal(Vector2D[, Vector2D]);

{Vector2D} vecRH

{Vector2D} [result]: 可选参数，用来保存结果

[Returns]: {Vector2D} 新的标准向量

Back to top

.isZero()

确定这个向量是否等于<0,0>

public {Boolean} isZero();

[Returns]: {Boolean} true 如果这个向量等于 <0,0>

Back to top

.magnitude()

计算这个向量的大小。注意:JavaScript中的函数对象已经有一个“length”成员，因此使用的是数量级。

public {Number} magnitude();

[Returns]: {Number} 这个矢量的大小

Back to top

.magnitudeSq()

计算这个向量的大小的平方。这个函数避免计算平方根，因此比 .magnitude( ) 略快。

public {Number} magnitudeSq();

[Returns]: {Number} 这个矢量的大小的平方

参见

.magnitude

Back to top

.multiply()

使用传递向量乘以这个向量

public {Vector2D} multiply(Vector2D);

{Vector2D} vecRH

[Returns]: {Vector2D} 向量的乘积

Back to top

.negate()

向量取反 (例如， <-x,-y>)

public {Vector2D} negate();

[Returns]: {Vector2D} 取反后的向量

Back to top

.normalize()

归一化向量(缩放这个向量使它新的大小为 1) 对于大小为0的向量, 返回 <1,0>。

public {Vector2D} normalize();

[Returns]: {Vector2D} 归一化之后的向量

Back to top

.perpendicular()

计算一个垂直于这个向量的新向量。垂直向量与这个向量的大小相同，将这个向量逆时针旋转90度得到新向量。

public {Vector2D} perpendicular([Vector2D]);

{Vector2D} [result]: 一个可选参数，用于保存结果

[Returns]: {Vector2D} 垂直的向量

Back to top

.scale()

使用传入的数量（s）缩放这个向量。如果 scalarY 被省略，则 scalarX 用于两个轴。

public {Vector2D} scale(Number[, Number]);

{Number} scalarX

{Number} [scalarY]

[Returns]: {Vector2D} 缩放后的向量

Back to top

.scaleToMagnitude()

对这个向量进行缩放，使它的新值等于传递的值。

public {Vector2D} scaleToMagnitude(Number);

{Number} mag

[Returns]: {Vector2D} 缩放后的向量

Back to top

.setValues()

用一个传递的向量或一对数字来设置这个向量的值。

public {Vector2D} setValues(Vector2D);

public {Vector2D} setValues(Number, Number);

{Number|Vector2D} x

{Number} y

[Returns]: {Vector2D} 设置后的向量

Back to top

.subtract()

将传递的向量从这个向量中减去。

public {Vector2D} subtract(Vector2D);

{Vector2D} vecRH

[Returns]: {vector2D} 减去后的向量

Back to top

.toString()

返回这个向量的字符串表示。

public {String} toString();

[Returns]: {String}

Back to top

.translate()

通过传递的数量转换(移动)这个向量。如果省略了dy，那么dx就被用于两个轴。

public {Vector2D} translate(Number[, Number]);

{Number} dx

{Number} [dy]

[Returns]: {Vector2D} 转换后的向量

Back to top

.tripleProduct()

计算三个向量的三重积。三重向量积=b(a•c)-a(b•c)

public {Vector2D} tripleProduct(Vector2D, Vector2D, Vector2D, [Vector2D]);

{Vector2D} a

{Vector2D} b

{Vector2D} c

{Vector2D} [result]: 可选参数，用于保存结果

[Returns]: {Vector2D} 三重积作为一个新矢量