DirectX12 3D游戏开发实践（龙书）第一章 向量代数

第一章 向量代数

向量与坐标系

定义

一种兼具大小和方向的量

坐标系

下图展现了向量v以及控件中俩组不同的标架（frame）
每当我们根据坐标来确定一个向量时，其对应的坐标总是相当于某一个参考系而言的。在3D计算图形学中，我们通常会用到较多的参考系。因此我们需要记录向量的每一种坐标系中对应的坐标。另外我们也需要知道如何将向量坐标在不同标架之间进行转换。

Direct3D采用的是左手坐标系，左手坐标系Z轴指向屏幕里，也就是眼睛看向方向，右手坐标系Z轴指向屏幕外，见下俩图。

向量的基本运算

点积是一种计算结果为标量值的向量乘法运算，因此有些时候也称标量积。设向量$u=（u_x，u_y，u_z）$，$v=（v_x，v_y，v_z）$，则点积的定义为：

$u\cdot v=u_x{v}_x+u_y{v}_y+u_z{v}_z$
可见，点积就是向量间对应分类的乘积之和。

点积的定义并没有明显地体现出其几何意义。但是我们却能根据余弦定理找到向量点积的几何关系：
$u\cdot v=\mid \mid u\mid \mid \mid \mid v\mid \mid cos\theta$
如果$u$与$v$是单位向量的话，那么有：
$u\cdot v=cos\theta$
此时我们就能通过点积计算得到向量的夹角的余弦值，也就能得到夹角度数。

正交投影投影线垂直于投影面的投影。
正交化一个集合里的向量都与一向量正交，且这个集合的向量都为单位向量，那我们将此集合称为规范正交，而将普通向量集正交化为规范正交集的过程叫做正交化。而这个过程就要使用格拉姆——施密特正交化（Gram-Schmidt Orthogonalization）方法进行处理。规范化步骤：$w_i=\frac{w_i}{||w_i||}$。

叉积（亦称向量积、外积）是向量的第二种乘法形式。与计算结果为标量的点积不同，叉积的计算结果亦为向量。叉积的计算方法为：
$w=u\times v=(u_y{v}_z-u_z{v}_y,u_z{v}_x-u_x{v}_z,u_x{v}_y-u_y{v}_x)$
若实际上采用的是左手坐标系，那么伸出左手，四指头伸直指向向量$u$，四指做握拳动作，四指弯曲的方向则是向量$v$的方向，那么此时，大拇指指向的方向则是向量$w$的方向。（注：如若此处用的是右手坐标系，那么用右手做同样操作即可），这个方法叫左手拇指法则，有的文献也称之为左手定则。

利用DirectXMath库对向量运算

DirectXMath使用环境

对于Windows8及其以上版本来讲，DirectXMath（其前身为XNA Math数据库，DirectXMath正是基于此而成）是一款Direct3D应用程序量身打造的3D数学库，而它也自此成为了WindowsSDK的一部分。该数据库采用了SIMD流指令扩展2(Streaming SIMD
Extensions2，SSE2)指令集。借助128位宽的单指令多数据(single instruction multiple data，SIMD)寄存器，利用一条指令SIMD指令即可同时对4个32位浮点数或整数进行运算。这对于向量运算带来的收益是不言而喻的。

为了使用DirectXMath库，我们需要添加头文件#include ，为了一些相关数据类型还需要加入头文件#include ，除此之外并不需要其他库文件，因为所有的代码都以内联的方式是现在头文件里。DirectXMath.h文件中的代码都存于DirectX命名空间中，DirectXPackedVector.h的代码则都位于DirectX::PackedVector中。
另外对于x86平台，我们需要启用SSE2指令集(Project Properties（工程属性） > Configuration Properties（配置属性） >
C/C++ > Code Generation（代码生成） > Enable Enhanced Instruction Set（启用增强子令） )。

对于所有平台，我们还应当启用快速浮点模型/fp:fast (Project Properties（工程属性） >
Configuration Properties（配置属性） > C/C++ > Code Generation（代码生成） > Floating Point Model（浮点模型）)。

对于x64平台来说，我们却不必开启SSE2指令集，这是因为所有的x64 CPU对此均有支持。

向量类型

DirectXMath中，核心向量时XMVECTOR,它将被映射到SIMD硬件寄存器中。通过SIMD指令的配合，利用这种具有128位的类型能一次性处理4个32位的浮点数。在开启SSE2后，此类型在x86和x64的定义是：

typedef __m128 XMVECTOR;

此处m128是特殊的SIMD类型（定义见xmmintrin.h）（采用联合的形式，这样用法的好处是可以同一段地址空间，做不同变量长度的字节数组使用）

typedef union __declspec(intrin_type) __declspec(align(16)) __m128 {
     float               m128_f32[4];
     unsigned __int64    m128_u64[2];
     __int8              m128_i8[16];
     __int16             m128_i16[8];
     __int32             m128_i32[4];
     __int64             m128_i64[2];
     unsigned __int8     m128_u8[16];
     unsigned __int16    m128_u16[8];
     unsigned __int32    m128_u32[4];
 } __m128;

对于类中的数据成员建议分别使用XMFLOAT2（2D），XMFLOAT2（3D），XMFLOAT2（4D）

struct XMFLOAT2
{
float x;
float y;
XMFLOAT2() {}
XMFLOAT2(float _x, float _y) : x(_x), y(_y) {}
explicit XMFLOAT2(_In_reads_(2) const float *pArray)
:
x(pArray[0]), y(pArray[1]) {}
XMFLOAT2& operator= (const XMFLOAT2& Float2)
{ x = Float2.x; y = Float2.y; return *this; }
};

struct XMFLOAT3
{
float x;
float y;
float z;
XMFLOAT3() {}
XMFLOAT3(float _x, float _y, float _z) : x(_x),
y(_y), z(_z) {}
explicit XMFLOAT3(_In_reads_(3) const float *pArray)
:
x(pArray[0]), y(pArray[1]), z(pArray[2]) {}
XMFLOAT3& operator= (const XMFLOAT3& Float3)
{ x = Float3.x; y = Float3.y; z = Float3.z; return
*this; }
};

struct XMFLOAT4
{
float x;
float y;
float z;
float w;
XMFLOAT4() {}
XMFLOAT4(float _x, float _y, float _z, float _w) :
x(_x), y(_y), z(_z), w(_w) {}
explicit XMFLOAT4(_In_reads_(4) const float *pArray)
:
x(pArray[0]), y(pArray[1]), z(pArray[2]),
w(pArray[3]) {}
XMFLOAT4& operator= (const XMFLOAT4& Float4)
{ x = Float4.x; y = Float4.y; z = Float4.z;
w = Float4.w; return *this; }
};

加载方法和存储方法

如果把上面的类型用于计算，却依然不能发挥SIMD技术的高效性，为此我们还需要将这些类型实例化转换为XMVECTOR类型。转换过程可以通过DirectXMath库的加载函数(loading function)实现。相反地，DirectXMath库也提供了用来将XMVECTOR类型转换为XMVECTn类型的存储函数。（想了很久不清楚它这里为什么要分别用俩种类型互相转换，而不是直接用XMVECTOR直接定义，我自己趋向的结果是类型明确，加上此程序开发者不关心其他类型的冗余数据，如果有什么官方解释，麻烦请留言，谢谢）。

用下面的方法将数据类型从XMFLOATn类型加载到XMVECTOR类型 ：

XMVECTOR XM_CALLCONV XMLoadFloat2(const XMFLOAT2 *pSource); 
XMVECTOR XM_CALLCONV XMLoadFloat3(const XMFLOAT3 *pSource); 
XMVECTOR XM_CALLCONV XMLoadFloat4(const XMFLOAT4 *pSource); 

用下面的方法将数据类型从XMVECTOR类型存储到XMFLOATn类型：

void XM_CALLCONV XMStoreFloat2(XMFLOAT2 *pDestination, FXVECTOR V);
void XM_CALLCONV XMStoreFloat3(XMFLOAT3 *pDestination, FXVECTOR V);
void XM_CALLCONV XMStoreFloat4(XMFLOAT4 *pDestination, FXVECTOR V);

当我们只期望从XMVECTOR 实例中得到某一向量分量或将某一向量转换为XMVECTOR类型时，相关存取方法如下：

float XM_CALLCONV XMVectorGetX(FXMVECTOR V);
float XM_CALLCONV XMVectorGetY(FXMVECTOR V);
float XM_CALLCONV XMVectorGetZ(FXMVECTOR V);
float XM_CALLCONV XMVectorGetW(FXMVECTOR V);

XMVECTOR XM_CALLCONV XMVectorSetX(FXMVECTOR V, float
x);
XMVECTOR XM_CALLCONV XMVectorSetY(FXMVECTOR V, float
y);
XMVECTOR XM_CALLCONV XMVectorSetZ(FXMVECTOR V, float
z);
XMVECTOR XM_CALLCONV XMVectorSetW(FXMVECTOR V, float
w);

参数传递

为了提高效率,可以将XMVECTOR类型的值作为函数的参数,直接送至SSE/SSE2寄存器里,而不存于栈内。以此方式传递的参数数量取决于用户使用的平台和编译器。因此为了使代码更具通用性，不受具体平台、编译器的影响，我们将利用FXMVECTOR、GXMVECTOR、HXMECTOR和CXMVECTOR类型来传递XMVECTOR类型的参数。基于特定的平台和编译器，它们会被自动地定义为适当的类型。

传递XMVECTOR参数的规则如下：

在32位的Windows系统上，编译器将根据__vectorcall调用约定将前3个，XMVECTOR参数传递到寄存器中，而把其余参数都存于栈上。
在64位的Windows系统上，编译器将根据__fastcall调用约定将前6个，`XMVECTOR参数传递到寄存器中，而把其余参数都存于栈上。

前3个XMVECTOR参数的类型都是应当用类型：FXMVECTOR；
第4个XMVECTOR参数应当用类型：GXMVECTOR；
第5、6个XMVECTOR参数应当用类型：HXMVECTOR；
其余的XMVECTOR参数应当用类型：CXMVECTOR；

构造函数对于这些规则来说是个例外，在编写时，前三个XMVECTOR参数用FXMVECTOR类型，其余用CXMVECTOR类型，另外对于构造函数，不要用XM_CALLCONV注解。
下面是截取自DirectXMath源码库：

inline XMMATRIX XM_CALLCONV XMMatrixTransformation(
FXMVECTOR ScalingOrigin,
FXMVECTOR ScalingOrientationQuaternion, .
FXMVECTOR Scaling,//第1~3个参数用FXMVECTOR
GXMVECTOR RotationOrigin,//第4个参数用GXMVECTOR
HXMVECTOR RotationQuaternion,
HXMVECTOR Translation);//5~6个参数用CXMVECTOR

当我们在这些参数之间掺杂其他不是XMVECTOR参数类型，此规则依旧可用：

inline XMMATRIX XM_CALLCONV XMMatrixTransformation2D(
FXMVECTOR ScalingOrigin,
float ScalingOrientation,
FXMVECTOR Scaling,
FXMVECTOR RotationOrigin,
float Rotation,
GXMVECTOR Translation);//第4个XMVECTOR参数

传递XMVECTOR参数的规则仅适用“输入”参数。“输出”的XMVECTOR参数则不会占用SSE/SSE2寄存器，所以他们的处理方式与非XMVECTOR类型的参数一致。

常向量

XMVECTOR类型的惨了实例应当用XMVECTORF32类型来表示。在DirectX SDK中就可以看到这种实例的运用：

static const XMVECTORF32 g_vHalfVector = { 0.5f, 0.5f,
0.5f, 0.5f };
static const XMVECTORF32 g_vZero = { 0.0f, 0.0f, 0.0f,
0.0f };
XMVECTORF32 vRightTop = {
vViewFrust.RightSlope,
vViewFrust.TopSlope,
1.0f,1.0f
};
XMVECTORF32 vLeftBottom = {
vViewFrust.LeftSlope,
vViewFrust.BottomSlope,
1.0f,1.0f
};

数学库中提供了将XMVECTORF32 转换成XMVECTOR类型的运算符：

__declspec(align(16)) struct XMVECTORF32
{
union
{
float f[4];
XMVECTOR v;
};
inline operator XMVECTOR() const { return v; }
inline operator const float*() const { return f; }
#if !defined(_XM_NO_INTRINSICS_) &&
defined(_XM_SSE_INTRINSICS_)
inline operator __m128i() const { return
_mm_castps_si128(v); }
inline operator __m128d() const { return
_mm_castps_pd(v); }
#endif
};

另外，也可以通过XMVECTORU32类型来创建由整数数据结构构成的XMVECTOR常量：

static const XMVECTORU32 vGrabY = {
0x00000000,0xFFFFFFFF,0x00000000,0x00000000
};

运算符重载

XMVECTOR类型针对于向量的加、减、标量乘、除，都分别提供了对应的重载运算符。

XMVECTOR XM_CALLCONV operator+ (FXMVECTOR V);
XMVECTOR XM_CALLCONV operator- (FXMVECTOR V);
XMVECTOR& XM_CALLCONV operator+= (XMVECTOR& V1,
FXMVECTOR V2);
XMVECTOR& XM_CALLCONV operator-= (XMVECTOR& V1,
FXMVECTOR V2);
XMVECTOR& XM_CALLCONV operator*= (XMVECTOR& V1,
FXMVECTOR V2);
XMVECTOR& XM_CALLCONV operator/= (XMVECTOR& V1,
FXMVECTOR V2);
XMVECTOR& operator*= (XMVECTOR& V, float S);
XMVECTOR& operator/= (XMVECTOR& V, float S);
XMVECTOR XM_CALLCONV operator+ (FXMVECTOR V1,
FXMVECTOR V2);
XMVECTOR XM_CALLCONV operator- (FXMVECTOR V1,
FXMVECTOR V2);
XMVECTOR XM_CALLCONV operator* (FXMVECTOR V1,
FXMVECTOR V2);
XMVECTOR XM_CALLCONV operator/ (FXMVECTOR V1,
FXMVECTOR V2);
XMVECTOR XM_CALLCONV operator* (FXMVECTOR V, float
S);
XMVECTOR XM_CALLCONV operator* (float S, FXMVECTOR
V);
XMVECTOR XM_CALLCONV operator/ (FXMVECTOR V, float
S);

杂项

DirectXMath库定义了一组与$\pi$有关的常用常量近似值：

const float XM_PI = 3.141592654f;
const float XM_2PI = 6.283185307f;
const float XM_1DIVPI = 0.318309886f;
const float XM_1DIV2PI = 0.159154943f;
const float XM_PIDIV2 = 1.570796327f;
const float XM_PIDIV4 = 0.785398163f;

另外，它用下列内联函数实现了弧度和角度间的互相转化：

inline float XMConvertToRadians(float fDegrees)
{ return fDegrees * (XM_PI / 180.0f); }
inline float XMConvertToDegrees(float fRadians)
{ return fRadians * (180.0f / XM_PI); }

DirectXMath库还定义了求出俩个数间较大值及较小值的函数：

template<class T> inline T XMMin(T a, T b) { return (a
< b) ? a : b; }
template<class T> inline T XMMax(T a, T b) { return (a
> b) ? a : b; }

Setter函数

DirectXMath库提供了下列函数，以设置XMVECTOR类型中的数据：

// Returns the zero vector 0
XMVECTOR XM_CALLCONV XMVectorZero();
// Returns the vector (1, 1, 1, 1)
XMVECTOR XM_CALLCONV XMVectorSplatOne();
// Returns the vector (x, y, z, w)
XMVECTOR XM_CALLCONV XMVectorSet(float x, float y,
float z, float w);
// Returns the vector (s, s, s, s)
XMVECTOR XM_CALLCONV XMVectorReplicate(float Value);
// Returns the vector (vx, vx, vx, vx)
XMVECTOR XM_CALLCONV XMVectorSplatX(FXMVECTOR V);
// Returns the vector (vy, vy, vy, vy)
XMVECTOR XM_CALLCONV XMVectorSplatY(FXMVECTOR V);
// Returns the vector (vz, vz, vz, vz)
XMVECTOR XM_CALLCONV XMVectorSplatZ(FXMVECTOR V);

实例程序：
#include //
#include
#include
#include
using namespace std;
using namespace DirectX;
using namespace DirectX::PackedVector;

//重载运算符<<，这样就可以通过Cout函数输出XMVECTOR对象

ostream& XM_CALLCONV operator<<(ostream& os, FXMVECTOR v)
{
	XMFLOAT3 dest;
	XMStoreFloat3(&dest, v);
	os << "(" << dest.x << ", " << dest.y << ", " <<
		dest.z << ")";
	return os;
} 
int main()
{
	cout.setf(ios_base::boolalpha);

	//检查是否支持SSE2指令集(Pentium4,AMD K8及后续版本的处理器)
	if (!XMVerifyCPUSupport())
	{
		cout << "directx math not supported" << endl;
		return 0;
	}
	XMVECTOR p = XMVectorZero();
	XMVECTOR q = XMVectorSplatOne();
	XMVECTOR u = XMVectorSet(1.0f, 2.0f, 3.0f, 0.0f);
	XMVECTOR v = XMVectorReplicate(-2.0f);
	XMVECTOR w = XMVectorSplatZ(u);
	cout << "p = " << p << endl;
	cout << "q = " << q << endl;
	cout << "u = " << u << endl;
	cout << "v = " << v << endl;
	cout << "w = " << w << endl;
	return 0;
}

运行结果：

向量函数

DirectXMath库提供了下面的函数来执行向量的各种运算，类似的有2D、3D、4D，下面的就是3D的部分函数。

XMVECTOR XM_CALLCONV XMVector3Length(FXMVECTOR V);
XMVECTOR XM_CALLCONV XMVector3LengthSq(FXMVECTOR V);
XMVECTOR XM_CALLCONV XMVector3Dot(FXMVECTOR V1,FXMVECTOR V2);
XMVECTOR XM_CALLCONV XMVector3Cross(FXMVECTOR V1,FXMVECTOR V2); 
XMVECTOR XM_CALLCONV XMVector3Normalize(FXMVECTOR V);
XMVECTOR XM_CALLCONV XMVector3Orthogonal(FXMVECTOR V);
XMVECTOR XM_CALLCONV XMVector3AngleBetweenVectors(FXMVECTOR V1,FXMVECTOR V2);
void XM_CALLCONV XMVector3ComponentsFromNormal(XMVECTOR* pParallel,XMVECTOR* pPerpendicular,FXMVECTOR V,FXMVECTOR Normal);
bool XM_CALLCONV XMVector3Equal(FXMVECTOR V1,FXMVECTOR V2);
bool XM_CALLCONV XMVector3NotEqual(FXMVECTOR V1,FXMVECTOR V2);

下面Demo演示一些函数与重载的使用：

#include  // for XMVerifyCPUSupport
#include 
#include 
#include 
using namespace std;
using namespace DirectX;
using namespace DirectX::PackedVector;

ostream& XM_CALLCONV operator<<(ostream& os, FXMVECTOR
	v)
{
	XMFLOAT3 dest;
	XMStoreFloat3(&dest, v);
	os << "(" << dest.x << ", " << dest.y << ", " <<
		dest.z << ")";
	return os;
}
int main()
{
	cout.setf(ios_base::boolalpha);
	if (!XMVerifyCPUSupport())
	{
		cout << "directx math not supported" << endl;
		return 0;
	}
	XMVECTOR n = XMVectorSet(1.0f, 0.0f, 0.0f, 0.0f);
	XMVECTOR u = XMVectorSet(1.0f, 2.0f, 3.0f, 0.0f);
	XMVECTOR v = XMVectorSet(-2.0f, 1.0f, -3.0f, 0.0f);
	XMVECTOR w = XMVectorSet(0.707f, 0.707f, 0.0f,
		0.0f);
	XMVECTOR a = u + v;
	XMVECTOR b = u - v;
	XMVECTOR c = 10.0f * u;
	XMVECTOR L = XMVector3Length(u);
	XMVECTOR d = XMVector3Normalize(u);
	XMVECTOR s = XMVector3Dot(u, v);
	XMVECTOR e = XMVector3Cross(u, v);
	XMVECTOR projW;
	XMVECTOR perpW;
	XMVector3ComponentsFromNormal(&projW, &perpW, w, n);
	bool equal = XMVector3Equal(projW + perpW, w) != 0;
	bool notEqual = XMVector3NotEqual(projW + perpW, w)
		!= 0;
		XMVECTOR
		angleVec = XMVector3AngleBetweenVectors(projW, perpW);
	float angleRadians = XMVectorGetX(angleVec);
	float
		angleDegrees = XMConvertToDegrees(angleRadians);
	cout << "u = " << u << endl;
	cout << "v = " << v << endl;
	cout << "w = " << w << endl;
	cout << "n = " << n << endl;
	cout << "a = u + v = " << a << endl;
	cout << "b = u - v = " << b << endl;
	cout << "c = 10 * u = " << c << endl;
	cout << "d = u / ||u || = " << d << endl;
	cout << "e = u x v = " << e << endl;
	cout << "L = || u || = " << L << endl;
	cout << "s = u.v = " << s << endl;
	cout << "projW = " << projW << endl;
	cout << "perpW = " << perpW << endl;
	cout << "projW + perpW == w = " << equal << endl;
	cout << "projW + perpW != w = " << notEqual << endl;
	cout << "angle = " << angleDegrees << endl;
	return 0;
}

运行结果如下：

浮点数误差

在用计算机处理向量有关工作时，我们应当了解以下工作内容，在比较浮点数时，一定要注意浮点数存在误差。我们认为相等的俩个浮点数可能会因此有细微的差别。例如，已知在数学上规范化向量长度为1，但是在计算机程序中的表达上，向量的长度只能接近于1。此外，在数学中，对于任意实数$p$有$1^p=1$。但是，当只能在数值上逼近1时，随着幂$p$的增加，所求近似值的误差也在逐渐增大，由此可见，数值误差时可以积累的。下面这个小程序可以印证这些观点：

#include  
#include 
#include 
#include 
using namespace std;
using namespace DirectX;
using namespace DirectX::PackedVector;
int main()
{
	cout.precision(8);
	//检查是否支持SSE2指令集(Pentium4，AMD K8以及其后续版本的处理器)
	if (!XMVerifyCPUSupport())
	{
		cout << "directx math not supported" << endl;
		return 0;
	}
	XMVECTOR u = XMVectorSet(1.0f, 1.0f, 1.0f, 0.0f);
	XMVECTOR n = XMVector3Normalize(u);
	float LU = XMVectorGetX(XMVector3Length(n));
	cout << LU << endl;
	if (LU == 1.0f)
		//在数学上，此向量的长度应当为1.
		cout << "Length 1" << endl;
	else
		cout << "Length not 1" << endl;
	float powLU = powf(LU, 1.0e6f);
	cout << "LU ^ (10 ^ 6) = " << powLU << endl;
}

运算结果：

因此为了弥补浮点数精确性上的不足，我们通过比较俩个浮点数是否近似相等来加以解决。在比较的时候，我们需要定义一个Epsilon常量，我们就说这俩个数是近似相等的。换句话说，Epsilon是针对浮点数的误差问题所指定的容差。下面函数解释了如何利用Epsilon来检测俩个浮点数是否相等：

const float Epsilon = 0.001f;
bool Equals(float lhs, float rhs)
{
//lhs与rhs的相差值是否小于EPSILON?
return fabs(lhs - rhs) < Epsilon ? true : false;
}

对此，DirectXMath库提供了XMVector3NearEqual函数，用于以Epsilon 作为容差，测试比较的向量是否相等：

// Returns
// abs(U.x – V.x) <= Epsilon.x &&
// abs(U.y – V.y) <= Epsilon.y &&
// abs(U.z – V.z) <= Epsilon.z
XMFINLINE bool XM_CALLCONV XMVector3NearEqual(
FXMVECTOR U,
FXMVECTOR V,
FXMVECTOR Epsilon);