原文:Introduction to 3D Game Programming with DirectX 12 学习笔记之 --- 第一章：向量代数
学习目标:
- 学习如何使用几何学和数字描述 Vector；
- 学习 Vector 的运算方法及其在几何学上的应用；
- 熟悉在 DirectXMath library 中的 Vector 相关的类和函数。
1 向量
一个向量代表的是一个拥有大小和方向的量。类似力（拥有力的大小和方向）、位移（移动的方向和距离）、速度（速度的大小和方向）等，例如下图（图 1.1）：
绘制向量的位置和向量本身无关，所以当且仅当两个向量的大小和方形相等时，两个向量相等；所以上图中a和b中的向量u和向量v相等。
1.1 向量和坐标系统
我们现在可以定义各种向量几何运算来解决对应的问题，但是因为计算机无法直接通过几何学计算向量，所以我们需要用数字来描述向量；
考虑到下图中的情况（图1.4），同一个向量在不同坐标系中会有不同的坐标变现：
在计算机3D图形学中我们需要使用多个坐标系，我们要知道当前在哪一个坐标系下，并且熟悉坐标系之间的转换。
1.2 左手坐标系 VS 右手坐标系
Direct3D 使用的是左手坐标系：如果你使用你的左手指向 X轴正方向，然后向Y轴正方向弯曲你的手指，此时你的大拇指指向的就是Z轴正方向，如图1.5 所示（右手坐标系类似，只不过替换为右手）
1.3 基本向量运算
我们也可以在坐标系中使用绘制的方法来表示：
2 长度和单位向量
向量长度计算公式：
单位向量计算公式：
为了证明单位向量计算公式，我们可以计算单位向量的长度：
3 向量的点积
向量的点积是一种结果为数量值的乘法形式，其定义和计算公式为：
向量的点积的定义并没有提出明显的几何定义，利用余弦定理，我们可以找到几何关系：
如图1.9，θ是向量v和u的夹角，再根据上面的公式，我们可以得出向量点积的一些有用的几何属性：
- 当两个向量点积为0时，两个向量垂直；
- 当两个向量点积大于0时，两个向量夹角小于90度；
- 当两个向量点积小于0时，两个向量夹角大于90度。
3.1 向量的分解
如图1.10
给出向量v和单位向量n，使用点积公式求出向量p：
向量p也可以表示为：p=projn(v)p = proj_n(v)p=projn(v)，那么向量w = v - p
所以向量v就可以分解为：v=p+w=projn(v)+perpn(v)v = p + w = proj_n(v) + perp_n(v)v=p+w=projn(v)+perpn(v)
如果向量n不是单位向量，那么可以提前把n标准化：
3.2 正交化
当一组向量相互之间都垂直，并且都是单位向量时，我们称他们为标准正交。在3D计算机图形学中，我们刚开始可能会有一组标准正交的向量，但是由于变量精度的问题，这些向量会在进行一系列计算后开始变得相互不垂直。所以我们的目标就是主要考虑在3D和2D情况下手动正交化。
我们先从2D开始，假设拥有向量v0v_0v0和v1v_1v1，我们要将他们正交化为标准正交集w0w_0w0和w1w_1w1；首先我们使w0=v0w_0=v_0w0=v0，然后修改v1v_1v1让它垂直于w0w_0w0：
在3D情况下，我们继续然后修改v2v_2v2让它同时垂直于w0w_0w0和w1w_1w1：
最后一步是标准化每一个向量为单位向量。
这套正交化流程我们统一称之为 施密特正交化（Gram-Schmidt Orthogonalization）。
4 向量的叉积
两个向量的叉积（叉积不支持2D）结果为另外一个同时垂直于他俩的向量，叉积的运算公式为：
叉积不支持交换律，其交换后的结果是相反的，即：u * v = - v * u。
4.1 伪2D叉积
在2D情况下，如果已知u=(ux,uy)u = (u_x, u_y)u=(ux,uy)，找出垂直于u的向量v=(−uy,ux)v = (-u_y, u_x)v=(−uy,ux)，该公式的证明如下：
4.2 使用叉积正交化
使用叉积正交化会造成一些误差
- 首先设置 w0=v0∣∣v0∣∣w_0 = \frac{v_0}{||v_0||}w0=∣∣v0∣∣v0；
- 设置 w2=w0×v1∣∣w0×v1∣∣w_2 = \frac{w_0 \times v_1}{||w_0 \times v_1||}w2=∣∣w0×v1∣∣w0×v1；
- 最后 w1=w2×w0w_1 = w_2 \times w_0w1=w2×w0，因为w2w_2w2和w0w_0w0都已经是单位向量，所以不需要对w1w_1w1做标准化。
5 点
点在3D图形学中要来表示位置，在坐标系中，一个向量可以表示一个位置。
一方面，我们对向量的运算不能应用到点上（比如两个点相加是没有意义的）；另一方面，我们可以把这些运算扩展到点上。
6 DIRECTX MATH 中的向量
Direct Math是Direct3D应用中的一个数学库，并且已经内置到了Window 8以上的操作系统。
该数学库使用 SSE2(Streaming SIMD Extensions 2) 系统指令，支持128位的 SIMD(single instruction multiple data) 寄存器。SIMD 指令可以在一条指令中运算4个32位的浮点数和整数。这对于向量的计算非常有用。
比如做4D向量的相加，我们不需要使用4条标量相加指令，而是1条SIMD指令即可，对于2D和3D向量也可以使用SIMD，我们可以无视不使用的坐标系。
如果想要了解DirectX Math的全部细节，推荐阅读DirectX Math的在线文档；
如果想要知道SIMD向量库如何优化开发，或者了解它为何如此设计，推荐阅读文章：Designing Fast Cross-Platform SIMD Vector Libraries by [Oliveira2010]。
使用DirectX Math时，需要的所有头文件：
#include <DirectXMath.h> // namespace: DirectX DirectX 数学库
#include <DirectXPackedVector.h> // namespace: DirectX::PackedVector 一些额外附加数据类型
对于X86系统，需要开启SSE2(Project Properties > Configuration Properties > C/C++ > Code Generation > Enable Enhanced Instruction Set)；
对于所有系统，还需要开启快速浮点数模式**(Project Properties > Configuration Properties > C/C++ > Code Generation > Floating Point Model**)；
对于64位系统不需要开启SSE2，因为所有64位CPU都支持SSE2(http://en.wikipedia.org/wiki/SSE2)。
6.1 向量的类型
DirectX Math 的核心类型是映射到SIMD硬件寄存器的 XMVECTOR，它是一个128位，可以使用单个指令计算4个32位浮点数的类型。对于X86和64位系统中，它的定义如下：
typedef __m128 XMVECTOR;
__m128是SIMD专用的类型。当我们计算的时候，向量必须声明位该类型才能利用SIMD的优点。
XMVECTOR的局部和全部变量会自动被16位对其；对于类的成员变量，使用XMFLOAT2 (2D)，XMFLOAT3 (3D)，和XMFLOAT4 (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的优点，所以我们需要进行类型的转换；DirectX Math中提供了Loading函数可以将XMFLOATn类型数据加载到XMVECTOR；Storage函数可以将XMVECTOR类型数据保存到XMFLOATn。
总结如下：
- 对于局部或者全局变量，使用XMVECTOR；
- 对于类的成员变量，使用XMFLOATn；
- 使用Loading和Storage函数对数据进行加载和保存；
- 计算的时候使用XMVECTOR类型；
6.2 Loading 和 Storage 方法
将数据从XMFLOATn加载到XMVECTOR的Loading方法如下：
// Loads XMFLOAT2 into XMVECTOR
XMVECTOR XM_CALLCONV XMLoadFloat2(const XMFLOAT2 *pSource);
// Loads XMFLOAT3 into XMVECTOR
XMVECTOR XM_CALLCONV XMLoadFloat3(const XMFLOAT3 *pSource);
// Loads XMFLOAT4 into XMVECTOR
XMVECTOR XM_CALLCONV XMLoadFloat4(const XMFLOAT4 *pSource);
将数据从XMVECTOR保存到XMFLOATn的Storage方法如下：
// Loads XMVECTOR into XMFLOAT2
void XM_CALLCONV XMStoreFloat2(XMFLOAT2 *pDestination, FXMVECTOR V);
// Loads XMVECTOR into XMFLOAT3
void XM_CALLCONV XMStoreFloat3(XMFLOAT3 *pDestination, FXMVECTOR V);
// Loads XMVECTOR into XMFLOAT4
void XM_CALLCONV XMStoreFloat4(XMFLOAT4 *pDestination, FXMVECTOR V);
有时我们只想修改或者获取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);
6.3 参数传递
为了优化性能为目的，XMVECTOR可以作为函数参数直接传递到SSE/SSE2寄存器中（而不是堆栈内存），参数传递的数量依赖于平台（例如：32/64位 Windows，Windows RT）和编译器。所以根据不同平台/编译器，我们使用FXMVECTOR，GXMVECTOR，HXMVECTOR 和 CXMVECTOR类型来传递XMVECTOR参数；此外，在函数名前要指明调用注释XM_CALLCONV
XMVECTOR类型参数传递规则如下：
- 前三个参数类型要定义为FXMVECTOR；
- 第四个要定义为GXMVECTOR；
- 第五个和第六个要定义为HXMVECTOR；
- 其他参数要定义为CXMVECTOR。
在32为Windows下，支持__fastcall调用约定和支持更新的__vectorcall调用约定编译中，参数定义如下：
// 32-bit Windows __fastcall passes first 3 XMVECTOR arguments
// via registers, the remaining on the stack.
typedef const XMVECTOR FXMVECTOR;
typedef const XMVECTOR& GXMVECTOR;
typedef const XMVECTOR& HXMVECTOR;
typedef const XMVECTOR& CXMVECTOR;
// 32-bit Windows __vectorcall passes first 6 XMVECTOR arguments
// via registers, the remaining on the stack.
typedef const XMVECTOR FXMVECTOR;
typedef const XMVECTOR GXMVECTOR;
typedef const XMVECTOR HXMVECTOR;
typedef const XMVECTOR& CXMVECTOR;
想了解在其他平台定义的更多细节，可以阅读DirectX Math的文档，“Library Internals” 下的 “Calling Conventions” ；
在构造函数中，这些规则是例外：文档推荐前三个参数使用FXMVECTOR，其他参数使用CXMVECTOR，并且不要为构造函数添加XM_CALLCONV；
inline XMMATRIX XM_CALLCONV XMMatrixTransformation(
FXMVECTOR ScalingOrigin,
FXMVECTOR ScalingOrientationQuaternion, .
FXMVECTOR Scaling,
GXMVECTOR RotationOrigin,
HXMVECTOR RotationQuaternion,
HXMVECTOR Translation);
函数调用时也可以添加非XMVECTOR类型参数，XMVECTOR参数定义规则相同，非XMVECTOR类型参数不计数：
inline XMMATRIX XM_CALLCONV XMMatrixTransformation2D(
FXMVECTOR ScalingOrigin,
float ScalingOrientation,
FXMVECTOR Scaling,
FXMVECTOR RotationOrigin,
float Rotation,
GXMVECTOR Translation);
这些规则只使用于输入参数，输出参数不使用SSE/SSE2寄存器，所以会被对待为和非XMVECTOR类型参数一样。
6.4 常量向量
常量向量的实例需要使用XMVECTORF32类型，下面是一些在DirectX SDK里CascadedShadowMaps11 Demo 下的例子：
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类型，它是一个16位对齐并带有XMVECTOR转换的结构体，它的定义如下：
// Conversion types for constants
__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 };
6.5 重载运算符
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);
6.6 其它
DirectX Math定义了一些有用的常量来近似的表现和 π 相关的值：
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); }
还定义了min/max函数：
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; }
6.7 Setter 函数
DirectX Math提供了下面函数用来修改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 <windows.h> // for XMVerifyCPUSupport
#include <DirectXMath.h>
#include <DirectXPackedVector.h>
using namespace std;
using namespace DirectX;
using namespace DirectX::PackedVector;
// Overload the "<<" operators so that we can use cout to
// output XMVECTOR objects.
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);
// Check support for SSE2 (Pentium4, AMD K8, and above).
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;
}
6.8 向量的函数
DirectX Math提供了下面的函数来处理各种向量运算，这里介绍3D版本，2D和4D版本于3D类似：
（有些可以直接返回值的函数依然返回的是XMVECTOR，比如向量的点积，这样做是为了尽可能减少SIMD和其它值的混合，从而提高性能）
XMVECTOR XM_CALLCONV XMVector3Length(
// Returns ||v||
FXMVECTOR V); // Input v
XMVECTOR XM_CALLCONV XMVector3LengthSq(
// Returns ||v||2
FXMVECTOR V); // Input v
XMVECTOR XM_CALLCONV XMVector3Dot(
// Returns v1·v2
FXMVECTOR V1, // Input v1
FXMVECTOR V2); // Input v2
XMVECTOR XM_CALLCONV XMVector3Cross(
// Returns v1 × v2
FXMVECTOR V1, // Input v1
FXMVECTOR V2); // Input v2
XMVECTOR XM_CALLCONV XMVector3Normalize(
// Returns v/||v||
FXMVECTOR V); // Input v
XMVECTOR XM_CALLCONV XMVector3Orthogonal(
// Returns a vector orthogonal to v
FXMVECTOR V); // Input v
XMVECTOR XM_CALLCONV XMVector3AngleBetweenVectors(
// Returns the angle between v1 and v2
FXMVECTOR V1, // Input v1
FXMVECTOR V2); // Input v2
void XM_CALLCONV XMVector3ComponentsFromNormal(
XMVECTOR* pParallel, // Returns projn(v)
XMVECTOR* pPerpendicular, // Returns perpn(v)
FXMVECTOR V, // Input v
FXMVECTOR Normal); // Input n
bool XM_CALLCONV XMVector3Equal(
// Returns v1 = v2
FXMVECTOR V1, // Input v1
FXMVECTOR V2); // Input v2
bool XM_CALLCONV XMVector3NotEqual(
// Returns v1 ≠ v2
FXMVECTOR V1, // Input v1
FXMVECTOR V2); // Input v2
下面的示例程序展示了大部分函数和一些重载云算符的用法：
#include <windows.h> // for XMVerifyCPUSupport
#include <DirectXMath.h>
#include <DirectXPackedVector.h>
#include <iostream>
using namespace std;
using namespace DirectX;
using namespace DirectX::PackedVector;
// Overload the "<<" operators so that we can use cout to
// output XMVECTOR objects.
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);
// Check support for SSE2 (Pentium4, AMD K8, and above).
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);
// Vector addition: XMVECTOR operator +
XMVECTOR a = u + v;
// Vector subtraction: XMVECTOR operator -
XMVECTOR b = u - v;
// Scalar multiplication: XMVECTOR operator *
XMVECTOR c = 10.0f*u;
// ||u||
XMVECTOR L = XMVector3Length(u);
// d = u / ||u||
XMVECTOR d = XMVector3Normalize(u);
// s = u dot v
XMVECTOR s = XMVector3Dot(u, v);
// e = u x v
XMVECTOR e = XMVector3Cross(u, v);
// Find proj_n(w) and perp_n(w)
XMVECTOR projW;
XMVECTOR perpW;
XMVector3ComponentsFromNormal(&projW, &perpW, w, n);
// Does projW + perpW == w?
bool equal = XMVector3Equal(projW + perpW, w) != 0;
bool notEqual = XMVector3NotEqual(projW + perpW, w) != 0;
// The angle between projW and perpW should be 90 degrees.
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;
}
DirectX Math还包含一些求近似值的函数，它们准确度较低，但是更快；如果你愿意牺牲准确度去追求速度，可以考虑使用它们，下面是其中的2个例子：
XMVECTOR XM_CALLCONV XMVector3LengthEst(
// Returns estimated ||v||
FXMVECTOR V); // Input v
XMVECTOR XM_CALLCONV XMVector3NormalizeEst(
// Returns estimated v/||v||
FXMVECTOR V); // Input v
6.9 浮点数误差
DirectX Math库提供了一个函数XMVector3NearEqual用以判断两个向量在可允许的误差下是否相等：
// 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);
7 总结
- 向量用来模拟在物理学中同时具有方向和长度的量；在几何学上，我们使用一个具有方向的线段来表示向量。当一个向量平行移动到使其尾部和坐标系原点重合的时候，它就是一个标准向量，标准向量可以使用它头部坐标来表示；
- 向量的基本运算公式：
- 当进行向量运算的时候，我们使用XMVECTOR类型来进行高效的SIMD操作；对于类的成员变量，我们使用XMFLOAT2，XMFLOAT3，和XMFLOAT4类型；然后使用Loading和Storage方法来进行它们之间的转化；
- 出于对效率考虑，XMVECTOR类型的数据可以作为函数参数直接传到SSE/SSE2寄存器中，为了独立于平台，我们使用FXMVECTOR，GXMVECTOR，HXMVECTOR 和 CXMVECTOR类型来传递XMVECTOR参数。传递的规则为：前三个参数使用FXMVECTOR类型，第四个参数使用GXMVECTOR类型，第五个和第六个参数使用HXMVECTOR类型，其它的使用CXMVECTOR类型；
- XMVECTOR类重载了算术运算符来计算加减和标量乘法；DirectX Math库还提供了很多有用的函数来计算向量的长度，向量长度的平方，向量的点积和叉积，向量标准化：
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);
8 练习题
- 令u = (1, 2)、v = (3, −4)，计算下面的值：
- 令u = (−1, 3, 2)、v = (3, −4, 1)，计算下面的值：
- 假设u = (ux, uy, uz)，v = (vx, vy, vz)和w = (wx, wy, wz)。并且c和k是标量，证明下面的等式：
- 解方程2((1, 2, 3) – x) − (−2, 0, 4) = −2(1, 2, 3)：
- 令u = (−1, 3, 2)、v = (3, −4, 1)，标准化u和v：
- 令k是一个标量，u = (ux, uy, uz)，证明||ku|| = |k|||u||：
- 求u和v的夹角是垂直、锐角还是钝角：
- 令u = (−1, 3, 2)和v = (3, −4, 1)，求u和v的夹角：
- 令u = (ux, uy, uz)、v = (vx, vy, vz)和w = (wx, wy, wz)，c和是标量，证明下面等式：
- 利用余弦法则（c2c^2c2 = a2a^2a2 + b2b^2b2 – 2abcosθ）证明uxvx+uyvy+uzvz=∣∣u∣∣∣∣v∣∣cosθu_xv_x + u_yv_y + u_zv_z = ||u||||v|| cosθuxvx+uyvy+uzvz=∣∣u∣∣∣∣v∣∣cosθ：
- 令n = (−2, 1)，将g = (0, −9.8)分解为2个向量，其中一个平行于n，另一个垂直于n：
- 令u = (−2, 1, 4)、v = (3, −4, 1)，求w = u × v，并且证明w · u = 0和w · v = 0：
- 3个点A = (0, 0, 0)，B = (0, 1, 3)和C = (5, 1, 0)在某坐标系中定义了一个三角形，找到一个垂直于该三角形的向量：
- 证明∣∣∣u×v∣∣=∣∣u∣∣∣∣v∣∣sinθ|||u\times v|| = ||u||||v||sinθ∣∣∣u×v∣∣=∣∣u∣∣∣∣v∣∣sinθ：
这个没有想到太好的办法，就是把sinθ转化为1−cos2θ\sqrt{1-cos^2θ}1−cos2θ，然后全部展开为uvxyzuv_{xyz}uvxyz，因为这种暴力破解法展开后等式会变得非常长，我懒得展了，看起来是一样哈哈。 - 证明||u ×v||的值是由u和v组成的平行四边形的面积：
- 给出一组3D向量u,v和w，证明u×(v×w)!=(u×v)×wu \times (v \times w) != (u \times v) \times wu×(v×w)!=(u×v)×w，这个代表了叉积不符合组合率：
- 证明两个非0平行向量的叉积是0：u × ku = 0。
- 使用施密特正交化方法，标准正交化下列向量：{(1, 0, 0), (1, 5, 0), (2, 1, −4)}
- 根据下列代码的输出，猜测每个XMVector*函数的作用，然后查阅DirectXMath的文档：
https://docs.microsoft.com/zh-cn/windows/desktop/dxmath/ovw-xnamath-reference-functions-vector
#include <windows.h> // for XMVerifyCPUSupport
#include <DirectXMath.h>
#include <DirectXPackedVector.h>
#include <iostream>
using namespace std;
using namespace DirectX;
using namespace DirectX::PackedVector;
// Overload the "<<" operators so that we can use cout to
// output XMVECTOR objects.
ostream& XM_CALLCONV operator<<(ostream& os, FXMVECTOR v)
{
XMFLOAT4 dest;
XMStoreFloat4(&dest, v);
os << "(" << dest.x << ", " << dest.y << ", " << dest.z << ", " << dest.w << ")";
return os;
}
int main()
{
cout.setf(ios_base::boolalpha);
// Check support for SSE2 (Pentium4, AMD K8, and above).
if (!XMVerifyCPUSupport())
{
cout << "directx math not supported" << endl;
return 0;
}
XMVECTOR p = XMVectorSet(2.0f, 2.0f, 1.0f, 0.0f);
XMVECTOR q = XMVectorSet(2.0f, -0.5f, 0.5f, 0.1f);
XMVECTOR u = XMVectorSet(1.0f, 2.0f, 4.0f, 8.0f);
XMVECTOR v = XMVectorSet(-2.0f, 1.0f, -3.0f, 2.5f);
XMVECTOR w = XMVectorSet(0.0f, XM_PIDIV4, XM_PIDIV2, XM_PI);
cout << "XMVectorAbs(v) = " << XMVectorAbs(v) << endl; // 对每一个分量求绝对值
cout << "XMVectorCos(w) = " << XMVectorCos(w) << endl; // 对每一个分量求arccosine值
cout << "XMVectorLog(u) = " << XMVectorLog(u) << endl; // 对每一个分量求log2的值
cout << "XMVectorExp(p) = " << XMVectorExp(p) << endl; // 对每一个分量乘2的值
cout << "XMVectorPow(u, p) = " << XMVectorPow(u, p) << endl; // 对u的每一个分量做p对应分量的平方
cout << "XMVectorSqrt(u) = " << XMVectorSqrt(u) << endl; // 对每一个分量开平方
cout << "XMVectorSwizzle(u, 2, 2, 1, 3) = " << XMVectorSwizzle(u, 2, 2, 1, 3) << endl; // XMVectorSwizzle 没看懂 - -！
cout << "XMVectorSwizzle(u, 2, 1, 0, 3) = " << XMVectorSwizzle(u, 2, 1, 0, 3) << endl; // XMVectorSwizzle 没看懂 - -！
cout << "XMVectorMultiply(u, v) = " << XMVectorMultiply(u, v) << endl; // 对每一个对应分量相乘
cout << "XMVectorSaturate(q) = " << XMVectorSaturate(q) << endl; // 把每一个分量修改为0~1的值
cout << "XMVectorMin(p, v = " << XMVectorMin(p, v) << endl; // 对每一个分量求 最小/最大 的值
cout << "XMVectorMax(p, v) = " << XMVectorMax(p, v) << endl; // 对每一个分量求 最小/最大 的值
system("pause");
return 0;
}