向量

第一章向量代数
- 向量与坐标系

第一章向量代数

向量与坐标系

定义

一种兼具大小和方向的量

坐标系

下图展现了向量v以及控件中俩组不同的标架（frame）
每当我们根据坐标来确定一个向量时，其对应的坐标总是相当于某一个参考系而言的。在3D计算图形学中，我们通常会用到较多的参考系。因此我们需要记录向量的每一种坐标系中对应的坐标。另外我们也需要知道如何将向量坐标在不同标架之间进行转换。
在这里插入图片描述
Direct3D采用的是左手坐标系，左手坐标系Z轴指向屏幕里，也就是眼睛看向方向，右手坐标系Z轴指向屏幕外，见下俩图。

向量的基本运算

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

u·v=u_xv_x+u_yv_y+u_zv_z

可见，点积就是向量间对应分类的乘积之和。

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

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

叉积（亦称向量积、外积）是向量的第二种乘法形式。与计算结果为标量的点积不同，叉积的计算结果亦为向量。叉积的计算方法为：
$\qquad \qquad \qquad \qquad \qquad \qquad \qquad \qquad \qquad w=u×v=(u_yv_z-u_zv_y,u_zv_x-u_xv_z,u_xv_y-u_yv_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 <DirectXMath.h>，为了一些相关数据类型还需要加入头文件#include <DirectXPackedVector.h>，除此之外并不需要其他库文件，因为所有的代码都以内联的方式是现在头文件里。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 <windows.h> //
#include <DirectXMath.h>
#include <DirectXPackedVector.h>
#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 <windows.h> // for XMVerifyCPUSupport
#include <DirectXMath.h>
#include <DirectXPackedVector.h>
#include <iostream>
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 <windows.h> 
#include <DirectXMath.h>
#include <DirectXPackedVector.h>
#include <iostream>
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);

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

向量

第一章向量代数

向量与坐标系

定义

坐标系

向量的基本运算

利用DirectXMath库对向量运算

DirectXMath使用环境

向量类型

加载方法和存储方法

参数传递

常向量

运算符重载

杂项

Setter函数

向量函数

浮点数误差

猜你喜欢

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

向量

第一章 向量代数

向量与坐标系

定义

坐标系

向量的基本运算

利用DirectXMath库对向量运算

DirectXMath使用环境

向量类型

加载方法和存储方法

参数传递

常向量

运算符重载

杂项

Setter函数

向量函数

浮点数误差

猜你喜欢

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

第一章向量代数