Java软光栅渲染器-三维向量

by 冰点

目标

  • 定义三维向量（Vector3f）类，实现向量的常用计算方法。
  • 扩展实现二维向量、四维向量。

源代码：

实现

三维向量

三维向量类的基本定义为：

public class Vector3f {
    public float x, y, z;
    
    public Vector3f() {
        x = y = z = 0;
    }

    public Vector3f(float x, float y, float z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }
}

Vector3f 可以用来表示三维空间中的一个“点”，这时 (x, y, z) 描述了该“点”在自身坐标系统中的相对位置。

Vector3f 也可以用来表示方向，看作是从原点 (0, 0, 0) 出发，指向 (x, y, z) 的箭头。这个“箭头”具有长度，也称为向量的模。

零向量

3D零向量表示为 (0, 0, 0)，它是唯一一个长度为0的向量。

    public final static Vector3f ZERO = new Vector3f(0, 0, 0);

负向量

把向量的各个分量求负，可得其负向量。简单地说就是 x + (-x) = 0。

负向量可以看作与原向量长度相同，但是方向相反的向量。

/**
 * 求负向量
 * 
 * @return
 */
public Vector3f negate() {
    return new Vector3f(-x, -y, -z);
}

/**
 * 求负向量
 * 
 * @return
 */
public Vector3f negateLocal() {
    x = -x;
    y = -y;
    z = -z;
    return this;
}

注意，这里我学习 jMonkeyEngine 写了2个不同的实现。

  • negate() 方法不会改变原向量，而是返回一个新的向量，它是原向量的负向量；
  • negateLocal() 方法会改变原向量自身的值，并返回该向量本身。

在进行Java游戏开发时，应该尽量避免实例化新的对象，以减少GC的工作量。在下文出现的其它方法中，如果不做特别声明，名为 xxxLocal() 的方法都意味着不会返回新的对象，而是修改当前对象的值。

向量大小（长度或模）

计算向量各分量的平方和，然后开根号即可。

/**
 * 返回向量的长度
 * 
 * @return
 */
public float length() {
    return (float) Math.sqrt(x * x + y * y + z * z);
}

开根号是一个相当昂贵的运算。如果只是想比较两个向量的大小，可以直接比较不开根号的值。若要判断向量长度是否为 1 或 0，也不需要开根号，因为1和0的平方等于它们本身。

所以，一般在3D数学库中，会提供这样一个方法，来返回未开根号的平方和：

/**
 * 返回向量长度的平方
 * 
 * @return
 */
public float lengthSquared() {
    return x * x + y * y + z * z;
}

出于性能考虑，我并没有在 length() 方法中调用 lengthSquared() 方法，因为调用方法时虚拟机会创建栈帧、压栈、弹栈。虽然这些操作的时间很短暂，但是累积起来也会影响程序的性能。

在后面的方法中，如无必要，也会尽量减少方法的调用。

标量与向量的乘法

标量与向量的乘法非常直接，将向量的每个分量都与标量相乘即可。

/**
 * 标量乘法
 * 
 * @param scalor
 * @return
 */
public Vector3f mult(float scalor) {
    return new Vector3f(x * scalor, y * scalor, z * scalor);
}

/**
 * 标量乘法
 * 
 * @param scalor
 * @return
 */
public Vector3f multLocal(float scalor) {
    x *= scalor;
    y *= scalor;
    z *= scalor;
    return this;
}

标准化向量

对于许多向量，我们只关心它的方向而不关心其大小。如：“我面向的是什么方向？”，这样的情况下使用单位向量更为简单。

单位向量就是长度为1的向量。单位向量经常也被称作标准化向量或更简单地称为 “法线”。

一般我会把与三个坐标轴平行的单位向量定义为常量。

public final static Vector3f UNIT_X = new Vector3f(1, 0, 0);
public final static Vector3f UNIT_Y = new Vector3f(0, 1, 0);
public final static Vector3f UNIT_Z = new Vector3f(0, 0, 1);

对于任意非零向量v，都可以计算出一个与它方向相同的单位向量。这个过程称作向量的“标准化”。要标准化向量，将向量除以它的大小（模）即可。

/**
 * 求单位向量
 */
public Vector3f normalize() {
    float length = x * x + y * y + z * z;
    if (length != 1f && length != 0f) {
        length = (float) (1.0 / Math.sqrt(length));
        return new Vector3f(x * length, y * length, z * length);
    }
    return new Vector3f(x, y, z);
}

/**
 * 求单位向量
 */
public Vector3f normalizeLocal() {
    float length = x * x + y * y + z * z;
    if (length != 1f && length != 0f) {
        length = (float) (1.0 / Math.sqrt(length));
        x *= length;
        y *= length;
        z *= length;
    }
    return this;
}

注意，这里又用了一个技巧来提升性能。计算机中的除法比乘法昂贵得多，因此 normalize() 方法先计算了 length 的倒数，再做了三次乘法，这样可以提升计算的速度。

零向量不能被标准化。数学上是不允许的，因为这将导致除零。几何上也没有意义，因为零向量没有方向。

向量的加法和减法

向量的加法运算法则很简单：两个向量相加，将对应的分量相加即可。

/**
 * 向量加法
 * 
 * @param v
 * @return
 */
public Vector3f add(Vector3f v) {
    return new Vector3f(x + v.x, y + v.y, z + v.z);
}

/**
 * 向量加法
 * @param v
 * @return
 */
public Vector3f addLocal(Vector3f v) {
    x += v.x;
    y += v.y;
    z += v.z;
    return this;
}

减法解释为负向量，a-b=a+(-b)。

/**
 * 向量减法
 * 
 * @param v
 * @return
 */
public Vector3f subtract(Vector3f v) {
    return new Vector3f(x - v.x, y - v.y, z - v.z);
}

/**
 * 向量减法
 * 
 * @param v
 * @return
 */
public Vector3f subtractLocal(Vector3f v) {
    x -= v.x;
    y -= v.y;
    z -= v.z;
    return this;
}

应该注意以下几点：

  • 向量不能与标量或维数不同的向量相加减
  • 和标量乘法一样，向量加法满足交换律，但是向量减法不满足交换律。永远有 a+b=b+a，但 a-b=-(b-a)，仅当a=b时，a-b=b-a。

向量a和b相加的几何解释为：平移向量，使向量a的头连接向量b的尾，接着从a的尾向b的头画一个向量。这就是向量加法的“三角形法则”。

向量的减法与之类似。

一个点到另一个点的向量

计算一个点到另一个点的位移是一种非常普遍的需求，可以使用三角形法则和向量减法来解决这个问题。下图展示了怎样用a-b来计算从点B到A的位移向量。

如图，将点A、B分别理解为从原点O开始的向量a、b，B到A的位移就可以用向量减法a-b来计算。

注意，减法a-b代表了从B到A的向量。简单地求“两点之间”的向量是没有意义的，因为没有指明方向。求一个点到另一个点的向量才有实际意义。

一个点到另一个点的线性插值

计算两点之间的向量很简单，如果需求改变一下，想要求两点之间某一点的向量呢？

例如：有一个物体，从起点出发向终点做匀速直线运动。走完全程需要的总时间为37秒，那么第11秒的时候这个物体运动到了什么位置？

把起点和终点看作两个向量，物体其实就是在从起点到终点的向量上运动。以该向量的总长度为100%，物体已经走完的路程为 t （0~100%），可得插值点的计算公式为：

interpolate = t * (final - begin)

经过化简，这个公式可以改写为：

interpolate = t * final + (1 - t) * begin

这个化简公式的几何意义也很简单：过插值点作一条平行于起点向量的辅助线，与终点向量所在的边相交。从交点的位置，可以得到两个更小的向量，插值点向量正好是这两个向量的和。根据相似三角形定理，可知这两个向量分别是 t * final 和 (1 - t) * begin。

代码实现如下：

/**
 * 在当前向量与final向量之间线性插值。
 * 
 * this=(1-changeAmnt)*this + changeAmnt * finalVec
 * @param finalVec 终向量
 * @param changeAmnt 插值系数，取值范围为 0.0 - 1.0。
 */
public Vector3f interpolateLocal(Vector3f finalVec, float changeAmnt) {
    this.x=(1-changeAmnt)*this.x + changeAmnt*finalVec.x;
    this.y=(1-changeAmnt)*this.y + changeAmnt*finalVec.y;
    this.z=(1-changeAmnt)*this.z + changeAmnt*finalVec.z;
    return this;
}

/**
 * 在当开始向量与终向量之间线性插值。
 * this=(1-changeAmnt)*beginVec + changeAmnt * finalVec
 * @param beginVec 开始向量（changeAmnt = 0）
 * @param finalVec 终向量（changeAmnt = 1）
 * @param changeAmnt 插值系数，取值范围为 0.0 - 1.0。
 */
public Vector3f interpolateLocal(Vector3f beginVec,Vector3f finalVec, float changeAmnt) {
    this.x=(1-changeAmnt)*beginVec.x + changeAmnt*finalVec.x;
    this.y=(1-changeAmnt)*beginVec.y + changeAmnt*finalVec.y;
    this.z=(1-changeAmnt)*beginVec.z + changeAmnt*finalVec.z;
    return this;
}

距离公式

距离公式用来计算两点之间的距离。从几何意义上来说，两点之间的距离等于从一个点到另一个点的向量的长度。先计算从a到b的向量d，然后再计算d的长度即可。

注意，哪个点是a和哪个点是b并不重要，因为我们只关心向量d的长度，不关心它的方向。

/**
 * 求两点之间的距离
 * 
 * @param v
 * @return
 */
public float distance(Vector3f v) {
    double dx = x - v.x;
    double dy = y - v.y;
    double dz = z - v.z;
    return (float) Math.sqrt(dx * dx + dy * dy + dz * dz);
}

/**
 * 求两点之间距离的平方
 * 
 * @param v
 * @return
 */
public float distanceSquared(Vector3f v) {
    double dx = x - v.x;
    double dy = y - v.y;
    double dz = z - v.z;
    return (float) (dx * dx + dy * dy + dz * dz);
}

向量点乘

向量的点乘也称作内积。向量点乘就是对应分量乘积的和，其结果是一个标量。

/**
 * 向量点乘（内积）
 * 
 * @param v
 * @return
 */
public float dot(Vector3f v) {
    return x * v.x + y * v.y + z * v.z;
}

点乘等于向量长度与向量夹角的cos值的积。

a dot b = |a|*|b|*cos(θ)

这个公式很有用，如果a、b都是单位向量，点乘就可以直接算出它们之间的 cos 值。根据cos值，即可以计算两个向量之间的夹角：

  • 若 cos > 0。说明a和b的夹角 0° <= θ < 90°；
  • 若 cos = 0，说明a和b正交（垂直），即 θ ≈ 90°；
  • 若 cos < 0，说明a和b的夹角 90° < θ <= 180°。

向量的大小并不影响点乘结果的符号，所以根据cos的符号就可以判断a和b的大致方向。

向量之间的夹角

利用点乘，很容易求得两个单位向量间的夹角。

/**
 * 求两个向量之间的夹角（弧度制）
 * 注意：参与运算的两个向量都应该是单位向量
 * 
 * @param v
 * @return
 */
public float angleBetween(Vector3f v) {
    float dotProduct = x * v.x + y * v.y + z * v.z;
    float angle = (float) Math.acos(dotProduct);
    return angle;
}

向量投影

已知两个向量a、b，可以把a分解成两个向量，一个垂直于b，另一个平行于b。平行于b的那个向量称为a在b上的投影。

根据向量点乘公式，易得两个向量夹角的 cos 值，根据 cos 值可以进一步求得向量的投影。

/**
 * 向量投影
 *
 * @param v
 * @return 返回一个新的向量，它平行于另一个向量。
 */
public Vector3f project(Vector3f v){
    float n = x * v.x + y * v.y + z * v.z; // A . B
    float d = v.lengthSquared(); // |B|^2
    float scalor = n / d;
    return new Vector3f(v.x * scalor, v.y * scalor, v.z * scalor);
}

/**
 * 向量投影
 * @param v
 * @return 返回一个新的向量，它平行于另一个向量。
 */
public Vector3f projectLocal(Vector3f v){
    float n = this.dot(v); // A . B
    float d = v.lengthSquared(); // |B|^2
    float scalor = n / d;
    x = v.x * scalor;
    y = v.y * scalor;
    z = v.z * scalor;
    return this;
}

向量叉乘

叉乘将会得到一个新的向量，它垂直于原来的两个向量，其长度 |a×b| 正好是以向量a、b位两边的平行四边形的面积。叉乘的这种特性，经常用于求三角形的表面法线。

/**
 * 向量叉乘（外积）
 * 
 * @param v
 * @return 返回一个新的向量，它垂直于当前两个向量。
 */
public Vector3f cross(Vector3f v) {
    float rx = y * v.z - z * v.y;
    float ry = z * v.x - x * v.z;
    float rz = x * v.y - y * v.x;
    return new Vector3f(rx, ry, rz);
}

/**
 * 向量叉乘（外积）
 * 
 * @param v
 * @return 返回一个新的向量，它垂直于当前两个向量。
 */
public Vector3f crossLocal(Vector3f v) {
    float tempX = y * v.z - z * v.y;
    float tempY = z * v.x - x * v.z;
    z = x * v.y - y * v.x;
    x = tempX;
    y = tempY;
    return this;
}

已知 a×b 垂直于a、b。但是垂直于a、b又两个方向。a×b指向哪个方向呢？通过将a的头与b的尾相接，并检查从a到b是顺时针还是逆时针，能够确定a×b的方向。

在右手坐标系中，如果a和b呈逆时针，则a×b指向您；如果a和b呈顺时针，则a×b远离您。

在左手坐标系中，则正好相反。如果a和b呈逆时针，则a×b远离您；如果a和b呈顺时针，则a×b指向您。

我们可以用右手来辅助记忆。将右手握拳，伸出大拇指指向自己，此时其他四指正好是逆时针方向，大拇指的方向就是a×b的方向。

现在你明白什么叫右手坐标系了吧。:)

向量的乘法

除点乘和叉乘外，还有另一种乘法，计算方法是直接将向量的分量相乘，它的几何意义是把向量按比例放大（缩小）。

/**
 * 向量乘法
 * 
 * @param v
 * @return
 */
public Vector3f mult(Vector3f v) {
    return new Vector3f(x * v.x, y * v.y, z * v.z);
}

/**
 * 向量乘法
 * 
 * @param v
 * @return
 */
public Vector3f multLocal(Vector3f v) {
    x *= v.x;
    y *= v.y;
    z *= v.z;
    return this;
}

向量的除法

向量的除法并没有太大的意义，可以用乘法来代替实现。不过有时为了简化计算工作，也会定义除法的规则。

向量除以标量，等于向量乘以这个标量的倒数：v / s = v * 1/s。

/**
 * 标量除法
 * @param scalor
 * @return
 */
public Vector3f divide(float scalor) {
    scalor = 1 / scalor;
    return new Vector3f(x * scalor, y * scalor, z * scalor);
}

/**
 * 标量除法
 * @param scalor
 * @return
 */
public Vector3f divideLocal(float scalor) {
    scalor = 1 / scalor;
    x *= scalor;
    y *= scalor;
    z *= scalor;
    return this;
}

向量a除以b，直接将各分量相除即可。

/**
 * 向量除法
 * @param v
 * @return
 */
public Vector3f divide(Vector3f v) {
    return new Vector3f( x / v.x, y / v.y, z / v.z);
}

/**
 * 向量除法
 * @param v
 * @return
 */
public Vector3f divideLocal(Vector3f v) {
    x /= v.x;
    y /= v.y;
    z /= v.z;
    return this;
}

注意，我没有在方法内做任何校验，但在做除法运算时应该要确保分母不为0。

总结

本章实现了三维向量的定义和各种运算。很多三维向量运算都可以推导到其他维度，比如二维向量和四维向量。

二维向量叉乘

比较特别的是，二维向量叉乘的结果是一个三维向量，它垂直于二维向量所在的平面。可以把二维向量当做是z分量为0的向量，然后计算叉乘：

(x1, y1, 0) cross (x2, y2, 0) = (0, 0, x1 * y2 - y1 * x2)

按照右手定则，如果向量v1和v2的方向为逆时针，叉乘向量就指向正方向。如果v1和v2的方向为顺时针，叉乘向量就指向负方向。根据 x1 * y2 - y1 * x2 的值，就可以判断向量v1和v2的方向。

在右手坐标系中，如果这个值大于0，说明v1和v2呈逆时针方向。换句话说，点v2位于向量v1的左侧。若值小于0，则说明点v2位于向量v1的右侧；当这个值为0时，说明向量 v1 和 v2 共线。

这个性质，在 Vector2f 类中用于判断向量的相对位置。

/**
 * 判别式
 */
public float determinant(Vector2f v) {
    return (x * v.y) - (y * v.x);
}


public Vector3f cross(Vector2f v) {
    return new Vector3f(0, 0, determinant(v));
}

四维向量初始化

在定义Vector4f时，我学习 Shader 语言中的用法，允许使用三维向量、二维向量来初始化四维向量。

/**
 * 使用一个三维向量+一个标量来构造四维向量。
 * @param v
 * @param w
 */
public Vector4f(Vector3f v, float w) {
    this.x = v.x;
    this.y = v.y;
    this.z = v.z;
    this.w = w;
}

/**
 * 使用2个二维向量来构造四维向量。
 * @param v0
 * @param v1
 */
public Vector4f(Vector2f v0, Vector2f v1) {
    this.x = v0.x;
    this.y = v0.y;
    this.z = v1.x;
    this.w = v1.y;
}

虽然不知道有什么用，但也许将来模拟着色器的时候用得着吧。