3D数学基础：图形与游戏开发(第6章3D向量类)笔记

3D向量类

1、类接口

思考

• 这个类将提供什么操作.
  -在哪些数据上执行这些操作.

基本操作

• 存取向量各分量（x、y和z）
• 向量间的赋值操作
• 比较两向量是否相同

执行操作

• 将向量置为零向量
• 向量求负
• 求向量的模
• 向量与标量的乘除法
• 向量标准化
• 向量加减法
• 计算两点间的距离
• 向量点乘
• 向量叉乘

2、Vector3类

#include<cstdio>
#include<cmath>

class Vector3
{
public:
    float x, y, z;
    Vector3() {}
    Vector3(const Vector3 &a) : x(a.x), y(a.y), z(a.z) {}
    Vector3(float nx, float ny, float nz) : x(nx), y(ny), z(nz) {}

    Vector3 &operator =(const Vector3 &a)
    {
        x = a.x; y = a.y; z = a.z;
        return *this;
    }

    bool operator ==(const Vector3 &a) const
    {
        return (x == a.x && y == a.y && z == a.z);
    }

    bool operator !=(const Vector3 &a) const
    {
        return (x != a.x || y != a.y || z != a.z);
    }

    Vector3 operator - () const
    {
        return Vector3(-x, -y, -z);
    }

    Vector3 operator + (const Vector3 &a) const
    {
        return Vector3(x + a.x, y + a.y, z + a.z);
    }

    Vector3 operator - (const Vector3 &a) const
    {
        return Vector3(x - a.x, y - a.y, z - a.z);
    }

    Vector3 operator * (const float a) const
    {
        return Vector3(x * a, y * a, z * a);
    }

    Vector3 operator / (const float a) const
    {
        float oneOverA = 1.0f / a;
        return Vector3(x * oneOverA, y * oneOverA, z * oneOverA);
    }

    Vector3 &operator += (const Vector3 &a)
    {
        x += a.x; y += a.y; z += a.z;
        return *this;
    }

    Vector3 &operator -= (const Vector3 &a)
    {
        x -= a.x; y -= a.y; z -= a.z;
        return *this;
    }

    Vector3 &operator *= (const float a)
    {
        x *= a; y *= a; z *= a;
        return *this;
    }

    Vector3 &operator /= (const float a)
    {
        float oneOverA = 1.0f / a;
        x *= oneOverA; y *= oneOverA; z *= oneOverA;
        return *this;
    }

    void zero()
    {
        x = y = z = 0.0f;
    }

    void normalize()
    {
        float magSq = x * x + y * y + z * z;
        if(magSq > 0.0f)
        {
            float oneOverMag = 1.0f / sqrt(magSq);
            x *= oneOverMag; y *= oneOverMag; z *= oneOverMag;
        }
    }

    float operator * (const Vector3 &a) const
    {
        return (x * a.x + y * a.y + z * a.z);
    }
};

inline float vector3Mag(const Vector3 &a)
{
    return sqrt(a.x * a.x + a.y * a.y + a.z * a.z);
}

inline Vector3 crossProduct(const Vector3 &a, const Vector3 &b)
{
    return Vector3(
                   a.y * b.z - a.z * b.y,
                   a.z * b.x - a.x * b.z,
                   a.x * b.y - a.y * b.x
                   );
}

inline Vector3 operator *(const float k, const Vector3 &v)
{
    return (v * k);
}

inline float distance(const Vector3 &a, const Vector3 &b)
{
    float dx = a.x - b.x;
    float dy = a.y - b.y;
    float dz = a.z - b.z;
    return sqrt(dx * dx + dy * dy + dz * dz);
}

extern const Vector3 kZeroVector3;

3、设计决策

float与double

在精度足够时，使用float可以为您节省可观的内存资源并且可能获得更好的性能。

运算符重载

类对象使用运算符时，会自动调用您所定义的函数。

仅提供最重要的操作

除非代码中有3个以上不同的位置用到了该操作，否则不要把它加到类中。

不要重载过多的运算符

首先要保证代码的清晰易懂，避免突发的错误比少敲几个键更重要。
特别的，不要重载以下经常被错误重载的操作:

• 叉乘
• 分量形式的乘除法
• 关系运算符
• 向量大小

使用const成员函数

应尽可能使用const成员函数，让函数对调用者承诺“不会修改对象”。

使用const引用参数

以传值方式传参会调用一次构造函数，传const引用在形式上是传值，而实际上是传址，避免了调用构造函数。

成员函数与非成员函数

成员函数在类定义中声明，作为类的成员被调用，它包含一个隐式的this指针作为形参。
那些只接收一个vector实参的操作，既可以被设计为成员函数，也可以被设计为非成员函数，对于这种操作，建议使用非成员函数。因为在vector表达式中非成员函数更易懂。

无缺省初始化

不要使用虚函数

• “自定义”向量操作没有太大意义。
• Vector3是一个严格要求速度的类，如果使用了虚函数，优化器通常不能产生成员函数的内联代码。
• 虚函数需要指向虚函数表的指针。向量定义时该指针必须被初始化，并使对象大小增加25%。
  总之虚函数并不适合向量类

不要使用屏蔽信息

信息屏蔽是指将成员变量声明在private和protected域中，仅能通过访问函数存取这些成员。
向量类没有”非变量”需要维护。

全局常量：零

用来向函数传递零向量，而不必每次都调用构造函数Vector3(0， 0， 0)来创建零向量。

不存在”Point3”类

关于优化

保持向量类越简单越好
一个著名的编程原则就是”95%的时间都消耗在5%的代码上”。
另一条关于优化的名言是：”过早的优化是一切罪恶的根源”。
维护一个临时对象池。
不要为2%的优化付出100%的代码复杂度。