月光林地

插件:批量重命名

发表于 2020-07-19 更新于 2021-08-02 分类于 plugin Changyan：

本文字数： 178 阅读时长 ≈ 1 分钟

由于自己平时在项目开发中经常遇到大批量的资源需要重命名，特别是美术资源如贴图、动画这些

而UE自带的批量操作又没有发现有重命名方法

所以就制作了这个简单的批量重命名的小插件

Github下载链接

动图演示

Rename

说明

Prefix前缀
Name:修改后的名称
StartIndex:在多选的情况下会自动生成序号，此选项为起始序号
Suffix:后缀
点击Rename按键就执行重命名

DX学习笔记（五）：绘制几何体2

发表于 2020-07-13 更新于 2021-08-02 分类于 graphics Changyan：

本文字数： 87k 阅读时长 ≈ 1:19

帧资源

上一篇在绘制每一帧都会进行一次CPU与GPU的同步,目的是

GPU未结束命令分配器中所有命令执行之前,不能重置,如果重置,那么GPU当前还未处理的命令就会被清除
对于常量缓冲区的数据而言,不同步的话会导致数据异常

所以我们用FlushCommandQueue来保持同步

但是有2个缺点导致性能浪费

每一帧起始阶段GPU无任务,处于闲置状态
帧结尾CPU处于闲置状态等待GPU完成绘制

帧资源

CPU会比GPU提前两帧工作,以保持GPU可持续工作

//存有CPU为构建美珍命令列表所需的资源
//其中的数据将依程序而异,取决于实际绘制所需的资源
struct FrameResource
{
public:
    
    FrameResource(ID3D12Device* device, UINT passCount, UINT objectCount);
    FrameResource(const FrameResource& rhs) = delete;
    FrameResource& operator=(const FrameResource& rhs) = delete;
    ~FrameResource();

    // CPU未结束命令分配器中所有命令执行之前,不能重置
    //因此每一帧都要有他们自己的命令分配器
    Microsoft::WRL::ComPtr<ID3D12CommandAllocator> CmdListAlloc;

    //在GPU完成引用此常量缓冲区的命令之前,我们不能对他进行更新
    //因此每一帧都要有他们自己的常量缓冲区
    std::unique_ptr<UploadBuffer<PassConstants>> PassCB = nullptr;
    std::unique_ptr<UploadBuffer<ObjectConstants>> ObjectCB = nullptr;

    // 通过围栏值将命令标记到此围栏点,这是我们可以检测到GPU是否还在使用这些帧资源
    UINT64 Fence = 0;
};


FrameResource::FrameResource(ID3D12Device* device, UINT passCount, UINT objectCount)
{
    ThrowIfFailed(device->CreateCommandAllocator(
        D3D12_COMMAND_LIST_TYPE_DIRECT,
		IID_PPV_ARGS(CmdListAlloc.GetAddressOf())));

    PassCB = std::make_unique<UploadBuffer<PassConstants>>(device, passCount, true);
    ObjectCB = std::make_unique<UploadBuffer<ObjectConstants>>(device, objectCount, true);
}

然后我们的应用程序类将用一个vector容器实例化3个帧资源对象

const int gNumFrameResources = 3;
std::vector<std::unique_ptr<FrameResource>> mFrameResources;
 FrameResource* mCurrFrameResource = nullptr;
 int mCurrFrameResourceIndex = 0;

void ShapesApp::BuildFrameResources()
{
    for(int i = 0; i < gNumFrameResources; ++i)
    {
        mFrameResources.push_back(std::make_unique<FrameResource>(md3dDevice.Get(),
            1, (UINT)mAllRitems.size()));
    }
}

然后在CPU处理第n帧的算法是如下

void ShapesApp::Update(const GameTimer& gt)
{

    // 循环获取帧资源数组中的元素
    mCurrFrameResourceIndex = (mCurrFrameResourceIndex + 1) % gNumFrameResources;
    mCurrFrameResource = mFrameResources[mCurrFrameResourceIndex].get();
    //GPU是否执行完所有命令?
    //如果还没有就令CPU等待,直到GPU完成所有命令的执行并且抵达这个围栏点
     if(mCurrFrameResource->Fence != 0 && mFence->GetCompletedValue() < mCurrFrameResource->Fence)
    {
        HANDLE eventHandle = CreateEventEx(nullptr, false, false, EVENT_ALL_ACCESS);
        ThrowIfFailed(mFence->SetEventOnCompletion(mCurrFrameResource->Fence, eventHandle));
        WaitForSingleObject(eventHandle, INFINITE);
        CloseHandle(eventHandle);
    }     
}

void ShapesApp::Draw(const GameTimer& gt)
{
    //.....构建命令列表
    
    //增加围栏点,将命令标记到此围栏点
     mCurrFrameResource->Fence = ++mCurrentFence;
    //向命令列表添加一条指令来设置一个新的围栏点
    //由于当前的GPU正在执行绘制命令,所以在GPU处理完Signal()函数之前的所有命令以前,并不会设置新的围栏点
     mCommandQueue->Signal(mFence.Get(), mCurrentFence);
}

这种处理无法完全避免等待的发生

如果GPU速度远大于CPU,,则GPU会处于空闲

反之,CPU会空闲,但是CPU空闲是有利的,因为CPU还需要处理其他算法

采用多帧资源的方法目的是让命令队列一直处于非空状态,即GPU一直有事情可以做

渲染项

单次绘制调用过程中,需要向渲染流水线提交的数据集成为渲染项

我们用一个轻量级的结构体来存储绘制物体所需的数据

struct RenderItem
{
	RenderItem() = default;

    // 描述了局部空间相对于世界空间的矩阵
    //定义了物体位于世界空间的位置,朝向和大小
    XMFLOAT4X4 World = MathHelper::Identity4x4();

	// 用dirty flag来标志物体的相关数据已经发生改变,意味着我们次数需要更新常量缓冲区
    // 由于每个帧资源中都有一个物体常量缓冲区,所以需要对每个帧资源进行更新
    //即,当修改物体数据时,应当按NumFramesDirty= gNumFrameReousreces进行设置,从而使每个帧资源都更新
	int NumFramesDirty = gNumFrameResources;

	// 该索引指向的GPU常量缓冲区对应当前渲染项中的物体常量缓冲区
	UINT ObjCBIndex = -1;

	MeshGeometry* Geo = nullptr;

    //图元拓扑
    D3D12_PRIMITIVE_TOPOLOGY PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;

    // DrawIndexedInstanced方法的参数
    UINT IndexCount = 0;
    UINT StartIndexLocation = 0;
    int BaseVertexLocation = 0;
};

渲染过程中所用到的常量数据

扩展常量缓冲区

//着色器
cbuffer cbPass : register(b1)
{
    float4x4 gView;
    float4x4 gInvView;
    float4x4 gProj;
    float4x4 gInvProj;
    float4x4 gViewProj;
    float4x4 gInvViewProj;
    float3 gEyePosW;
    float cbPerObjectPad1;
    float2 gRenderTargetSize;
    float2 gInvRenderTargetSize;
    float gNearZ;
    float gFarZ;
    float gTotalTime;
    float gDeltaTime;
};

//与之对应的常量缓冲区数据结构
struct PassConstants
{
    DirectX::XMFLOAT4X4 View = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 InvView = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 Proj = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 InvProj = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 ViewProj = MathHelper::Identity4x4();
    DirectX::XMFLOAT4X4 InvViewProj = MathHelper::Identity4x4();
    DirectX::XMFLOAT3 EyePosW = { 0.0f, 0.0f, 0.0f };
    float cbPerObjectPad1 = 0.0f;
    DirectX::XMFLOAT2 RenderTargetSize = { 0.0f, 0.0f };
    DirectX::XMFLOAT2 InvRenderTargetSize = { 0.0f, 0.0f };
    float NearZ = 0.0f;
    float FarZ = 0.0f;
    float TotalTime = 0.0f;
    float DeltaTime = 0.0f;
};

刷新常量缓冲区

void ShapesApp::UpdateObjectCBs(const GameTimer& gt)
{
	auto currObjectCB = mCurrFrameResource->ObjectCB.get();
	for(auto& e : mAllRitems)
	{
		// 只对发生常量改变的缓冲区刷新
		if(e->NumFramesDirty > 0)
		{
			XMMATRIX world = XMLoadFloat4x4(&e->World);

			ObjectConstants objConstants;
			XMStoreFloat4x4(&objConstants.World, XMMatrixTranspose(world));

			currObjectCB->CopyData(e->ObjCBIndex, objConstants);

			// 还需要对下一个FrameResource更新
			e->NumFramesDirty--;
		}
	}
}

void ShapesApp::UpdateMainPassCB(const GameTimer& gt)
{
	XMMATRIX view = XMLoadFloat4x4(&mView);
	XMMATRIX proj = XMLoadFloat4x4(&mProj);

	XMMATRIX viewProj = XMMatrixMultiply(view, proj);
	XMMATRIX invView = XMMatrixInverse(&XMMatrixDeterminant(view), view);
	XMMATRIX invProj = XMMatrixInverse(&XMMatrixDeterminant(proj), proj);
	XMMATRIX invViewProj = XMMatrixInverse(&XMMatrixDeterminant(viewProj), viewProj);

	XMStoreFloat4x4(&mMainPassCB.View, XMMatrixTranspose(view));
	XMStoreFloat4x4(&mMainPassCB.InvView, XMMatrixTranspose(invView));
	XMStoreFloat4x4(&mMainPassCB.Proj, XMMatrixTranspose(proj));
	XMStoreFloat4x4(&mMainPassCB.InvProj, XMMatrixTranspose(invProj));
	XMStoreFloat4x4(&mMainPassCB.ViewProj, XMMatrixTranspose(viewProj));
	XMStoreFloat4x4(&mMainPassCB.InvViewProj, XMMatrixTranspose(invViewProj));
	mMainPassCB.EyePosW = mEyePos;
	mMainPassCB.RenderTargetSize = XMFLOAT2((float)mClientWidth, (float)mClientHeight);
	mMainPassCB.InvRenderTargetSize = XMFLOAT2(1.0f / mClientWidth, 1.0f / mClientHeight);
	mMainPassCB.NearZ = 1.0f;
	mMainPassCB.FarZ = 1000.0f;
	mMainPassCB.TotalTime = gt.TotalTime();
	mMainPassCB.DeltaTime = gt.DeltaTime();

	auto currPassCB = mCurrFrameResource->PassCB.get();
	currPassCB->CopyData(0, mMainPassCB);
}

着色器改变

VertexOut VS(VertexIn vin)
{
	VertexOut vout;
	
	// Transform to homogeneous clip space.
    float4 posW = mul(float4(vin.PosL, 1.0f), gWorld);
    vout.PosH = mul(posW, gViewProj);
	
	// Just pass vertex color into the pixel shader.
    vout.Color = vin.Color;
    
    return vout;
}

调整根签名

void ShapesApp::BuildRootSignature()
{
    // 创建2个描述
    CD3DX12_DESCRIPTOR_RANGE cbvTable0;
    cbvTable0.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0);

    CD3DX12_DESCRIPTOR_RANGE cbvTable1;
    cbvTable1.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 1);

	// 2个成员的描述符表
	CD3DX12_ROOT_PARAMETER slotRootParameter[2];

	// 创建根CBV
    slotRootParameter[0].InitAsDescriptorTable(1, &cbvTable0);
    slotRootParameter[1].InitAsDescriptorTable(1, &cbvTable1);


	CD3DX12_ROOT_SIGNATURE_DESC rootSigDesc(2, slotRootParameter, 0, nullptr, 
        D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
//*************************
}

不同形状的几何体

GeometryGenerator类

class GeometryGenerator
{
public:

    using uint16 = std::uint16_t;
    using uint32 = std::uint32_t;

	struct Vertex
	{
		Vertex(){}
        Vertex(
            const DirectX::XMFLOAT3& p, 
            const DirectX::XMFLOAT3& n, 
            const DirectX::XMFLOAT3& t, 
            const DirectX::XMFLOAT2& uv) :
            Position(p), 
            Normal(n), 
            TangentU(t), 
            TexC(uv){}
		Vertex(
			float px, float py, float pz, 
			float nx, float ny, float nz,
			float tx, float ty, float tz,
			float u, float v) : 
            Position(px,py,pz), 
            Normal(nx,ny,nz),
			TangentU(tx, ty, tz), 
            TexC(u,v){}

        DirectX::XMFLOAT3 Position;
        DirectX::XMFLOAT3 Normal;
        DirectX::XMFLOAT3 TangentU;
        DirectX::XMFLOAT2 TexC;
	};

	struct MeshData
	{
		std::vector<Vertex> Vertices;
        std::vector<uint32> Indices32;

        std::vector<uint16>& GetIndices16()
        {
			if(mIndices16.empty())
			{
				mIndices16.resize(Indices32.size());
				for(size_t i = 0; i < Indices32.size(); ++i)
					mIndices16[i] = static_cast<uint16>(Indices32[i]);
			}

			return mIndices16;
        }

	private:
		std::vector<uint16> mIndices16;
	};

//创建盒子
    MeshData CreateBox(float width, float height, float depth, uint32 numSubdivisions);

//创建球体
    MeshData CreateSphere(float radius, uint32 sliceCount, uint32 stackCount);
//创建以给定的半径创建一个以原点为中心的地层
    MeshData CreateGeosphere(float radius, uint32 numSubdivisions);

///创建一个平行于y轴并以原点为中心的圆柱体。
///上下半径可以变化以形成各种圆锥形状，而不是真实的圆柱体。 切片和堆栈参数控制镶嵌的程度。
    MeshData CreateCylinder(float bottomRadius, float topRadius, float height, uint32 sliceCount, uint32 stackCount);
    
//在xz平面中以m行和n列为中心创建一个mxn网格,在具有指定宽度和深度的原点。
    MeshData CreateGrid(float width, float depth, uint32 m, uint32 n);

//创建与屏幕对齐的四边形。 这对于后期处理和屏幕效果很有用。
    MeshData CreateQuad(float x, float y, float w, float h, float depth);

private:
	void Subdivide(MeshData& meshData);
    Vertex MidPoint(const Vertex& v0, const Vertex& v1);
    void BuildCylinderTopCap(float bottomRadius, float topRadius, float height, uint32 sliceCount, uint32 stackCount, MeshData& meshData);
    void BuildCylinderBottomCap(float bottomRadius, float topRadius, float height, uint32 sliceCount, uint32 stackCount, MeshData& meshData);
};

细分

void GeometryGenerator::Subdivide(MeshData& meshData)
{
		//       v1
		//       *
		//      / \
		//     /   \
		//  m0*-----*m1
		//   / \   / \
		//  /   \ /   \
		// *-----*-----*
		// v0    m2     v2
		//****我里个去*****

		//保存一份拷贝
	MeshData inputCopy=meshData;
	meshData.Vertices.resize(0);
	meshData.Indices32.reserve(0);//清空

	uint32 numTris =(uint32)inputCopy.Indices32.size()/3; //三角形数量
	for (uint32 i=0;i<numTris;++i)
	{
		Vertex v0 = inputCopy.Vertices[inputCopy.Indices32[i * 3 + 0]];
		Vertex v1 = inputCopy.Vertices[inputCopy.Indices32[i * 3 + 1]];
		Vertex v2 = inputCopy.Vertices[inputCopy.Indices32[i * 3 + 2]];


		//创建中间点
		Vertex m0 = MidPoint(v0, v1);
		Vertex m1 = MidPoint(v1, v2);
		Vertex m2 = MidPoint(v0, v2);

		//添加新的几何体
		meshData.Vertices.push_back(v0); // 0
		meshData.Vertices.push_back(v1); // 1
		meshData.Vertices.push_back(v2); // 2
		meshData.Vertices.push_back(m0); // 3
		meshData.Vertices.push_back(m1); // 4
		meshData.Vertices.push_back(m2); // 5

		meshData.Indices32.push_back(i * 6 + 0);
		meshData.Indices32.push_back(i * 6 + 3);
		meshData.Indices32.push_back(i * 6 + 5);

		meshData.Indices32.push_back(i * 6 + 3);
		meshData.Indices32.push_back(i * 6 + 4);
		meshData.Indices32.push_back(i * 6 + 5);

		meshData.Indices32.push_back(i * 6 + 5);
		meshData.Indices32.push_back(i * 6 + 4);
		meshData.Indices32.push_back(i * 6 + 2);

		meshData.Indices32.push_back(i * 6 + 3);
		meshData.Indices32.push_back(i * 6 + 1);
		meshData.Indices32.push_back(i * 6 + 4);
	}

}

中间点的生成

Vertex GeometryGenerator::MidPoint(const Vertex& v0, const Vertex& v1)
{
	XMVECTOR p0 = XMLoadFloat3(&v0.Position);
	XMVECTOR p1 = XMLoadFloat3(&v1.Position);

	XMVECTOR n0 = XMLoadFloat3(&v0.Normal);
	XMVECTOR n1 = XMLoadFloat3(&v1.Normal);
	
	XMVECTOR tan0 = XMLoadFloat3(&v0.TangentU);
	XMVECTOR tan1 = XMLoadFloat3(&v1.TangentU);

	XMVECTOR tex0 = XMLoadFloat2(&v0.TexC);
	XMVECTOR tex1 = XMLoadFloat2(&v1.TexC);

	//计算中间数据
	XMVECTOR pos=0.5f*(p0+p1);
	XMVECTOR normal=XMVector3Normalize(0.5f*(n0+n1));
	XMVECTOR tangent = XMVector3Normalize(0.5f*(tan0 + tan1));
	XMVECTOR tex = 0.5f*(tex0 + tex1);

	Vertex v;
	XMStoreFloat3(&v.Position,pos);
	XMStoreFloat3(&v.Normal, normal);
	XMStoreFloat3(&v.TangentU, tangent);
	XMStoreFloat2(&v.TexC, tex);

	return v;

}

盒子

GeometryGenerator::MeshData GeometryGenerator::CreateBox(float width, float height, float depth, uint32 numSubdivisions)
{
	MeshData meshData;

	/*
	构建顶点
	*/

	Vertex v[24];
	float w2 = 0.5f*width;
	float h2 = 0.5f*height;
	float d2 = 0.5f*depth;

	// 前面
	v[0] = Vertex(-w2, -h2, -d2, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
	v[1] = Vertex(-w2, +h2, -d2, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
	v[2] = Vertex(+w2, +h2, -d2, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f);
	v[3] = Vertex(+w2, -h2, -d2, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f);

	// 后面
	v[4] = Vertex(-w2, -h2, +d2, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f);
	v[5] = Vertex(+w2, -h2, +d2, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
	v[6] = Vertex(+w2, +h2, +d2, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
	v[7] = Vertex(-w2, +h2, +d2, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f);

	// 顶部面
	v[8] = Vertex(-w2, +h2, -d2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
	v[9] = Vertex(-w2, +h2, +d2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
	v[10] = Vertex(+w2, +h2, +d2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f);
	v[11] = Vertex(+w2, +h2, -d2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f);

	// 底部面
	v[12] = Vertex(-w2, -h2, -d2, 0.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f);
	v[13] = Vertex(+w2, -h2, -d2, 0.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
	v[14] = Vertex(+w2, -h2, +d2, 0.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
	v[15] = Vertex(-w2, -h2, +d2, 0.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f);

	// 左边面
	v[16] = Vertex(-w2, -h2, +d2, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
	v[17] = Vertex(-w2, +h2, +d2, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
	v[18] = Vertex(-w2, +h2, -d2, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);
	v[19] = Vertex(-w2, -h2, -d2, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f);

	// 右边面
	v[20] = Vertex(+w2, -h2, -d2, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f);
	v[21] = Vertex(+w2, +h2, -d2, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
	v[22] = Vertex(+w2, +h2, +d2, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f);
	v[23] = Vertex(+w2, -h2, +d2, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f);


	meshData.Vertices.assign(&v[0],&v[24]);



	/*
	构建序列
	*/

	uint32 i[36];

	// Fill in the front face index data
	i[0] = 0; i[1] = 1; i[2] = 2;
	i[3] = 0; i[4] = 2; i[5] = 3;

	// Fill in the back face index data
	i[6] = 4; i[7] = 5; i[8] = 6;
	i[9] = 4; i[10] = 6; i[11] = 7;

	// Fill in the top face index data
	i[12] = 8; i[13] = 9; i[14] = 10;
	i[15] = 8; i[16] = 10; i[17] = 11;

	// Fill in the bottom face index data
	i[18] = 12; i[19] = 13; i[20] = 14;
	i[21] = 12; i[22] = 14; i[23] = 15;

	// Fill in the left face index data
	i[24] = 16; i[25] = 17; i[26] = 18;
	i[27] = 16; i[28] = 18; i[29] = 19;

	// Fill in the right face index data
	i[30] = 20; i[31] = 21; i[32] = 22;
	i[33] = 20; i[34] = 22; i[35] = 23;

	meshData.Indices32.assign(&i[0],&i[36]);


	//细分
	numSubdivisions = std::min<uint32>(numSubdivisions,6u);

	for (uint32 i = 0;i<numSubdivisions;++i)
	{
		Subdivide(meshData);//细分
	}
	return meshData;
}

球体

GeometryGenerator::MeshData GeometryGenerator::CreateSphere(float radius, uint32 sliceCount, uint32 stackCount)
{	
	MeshData meshData;

	Vertex topVertex(0.0f,+radius, 0.0f, 0.0f, +1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);//顶部顶点
	Vertex bottomVertex(0.0f, -radius, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);//底部顶点

	meshData.Vertices.push_back(topVertex);//添加顶部顶点

	float phiStep = XM_PI/stackCount;//水平面分段
	float thetaStep=2.0f*XM_PI/sliceCount;//竖直面分段

	for (uint32 i=0;i<=stackCount-1;++i)
	{
		float phi = i*phiStep;//yaw角度

		for (uint32 j = 0 ;j<=sliceCount;++j)
		{
			float theta=j*thetaStep;//pitch角度
			
			Vertex v;

			v.Position.x = radius*sinf(phi)*cosf(theta);
			v.Position.y = radius * cosf(phi);
			v.Position.z = radius * sinf(phi)*sinf(theta);

			v.TangentU.x = -radius * sinf(phi)*sinf(theta);
			v.TangentU.y = 0.0f;
			v.TangentU.z = +radius * sinf(phi)*cosf(theta);

			XMVECTOR T = XMLoadFloat3(&v.TangentU);
			XMStoreFloat3(&v.TangentU, XMVector3Normalize(T));

			XMVECTOR p = XMLoadFloat3(&v.Position);
			XMStoreFloat3(&v.Normal, XMVector3Normalize(p));

			v.TexC.x = theta / XM_2PI;
			v.TexC.y = phi / XM_PI;

			meshData.Vertices.push_back(v);
		}
	}

	//最底下一个顶点
	meshData.Vertices.push_back(bottomVertex);




	//顶部面所有点的索引
	for (uint32 i = 1; i <= sliceCount; ++i)
	{
		meshData.Indices32.push_back(0);
		meshData.Indices32.push_back(i + 1);
		meshData.Indices32.push_back(i);
	}

	uint32 baseIndex = 1;
	uint32 ringVertexCount = sliceCount + 1;
	//高度细分数量-2，因为顶部底部不算在内
	for (uint32 i = 0; i < stackCount - 2; ++i)
	{
		for (uint32 j = 0; j < sliceCount; ++j)
		{
			meshData.Indices32.push_back(baseIndex + i * ringVertexCount + j);
			meshData.Indices32.push_back(baseIndex + i * ringVertexCount + j + 1);
			meshData.Indices32.push_back(baseIndex + (i + 1)*ringVertexCount + j);

			meshData.Indices32.push_back(baseIndex + (i + 1)*ringVertexCount + j);
			meshData.Indices32.push_back(baseIndex + i * ringVertexCount + j + 1);
			meshData.Indices32.push_back(baseIndex + (i + 1)*ringVertexCount + j + 1);
		}
	}

	//底部的点的序号
	uint32 southPoleIndex = (uint32)meshData.Vertices.size() - 1;
	baseIndex = southPoleIndex - ringVertexCount;
	//底部面所有索引
	for (uint32 i = 0; i < sliceCount; ++i)
	{
		meshData.Indices32.push_back(southPoleIndex);
		meshData.Indices32.push_back(baseIndex + i);
		meshData.Indices32.push_back(baseIndex + i + 1);
	}

	return meshData;
}

柱体网格

GeometryGenerator::MeshData GeometryGenerator::CreateCylinder(float bottomRadius, float topRadius, float height, uint32 sliceCount, uint32 stackCount)
{

	MeshData meshData;
	//高度递增
	float stackHeight = height / stackCount;
	//从底部开始，每一次半径递增
	float radiusStep = (topRadius - bottomRadius) / stackCount;
	//环数
	uint32 rightCount = stackCount +1;
	for (uint32 i=0;i<rightCount;++i)
	{
		float y = -0.5f*height + i*stackHeight;//从底部开始往上加高度
		float r = bottomRadius+i*radiusStep;

		float dTheta= 2.0f*XM_PI/sliceCount;//360角度范围的弧度,水平角度yaw
		for (uint32 j=0;j<=sliceCount;++j)
		{
			Vertex vertex;

			float c = cosf(j*dTheta);
			float s = sinf(j*dTheta);

			vertex.Position=XMFLOAT3(r*c,y,r*s);
			vertex.TexC.x = (float)j/sliceCount;
			vertex.TexC.y = 1.0f - (float)i / stackCount;
			vertex.TangentU = XMFLOAT3(-s, 0.0f, c);
			float dr = bottomRadius - topRadius;
			XMFLOAT3 bitangent(dr*c, -height, dr*s);
			XMVECTOR T = XMLoadFloat3(&vertex.TangentU);
			XMVECTOR B = XMLoadFloat3(&bitangent);
			XMVECTOR N = XMVector3Normalize(XMVector3Cross(T, B));
			XMStoreFloat3(&vertex.Normal, N);

			meshData.Vertices.push_back(vertex);
		}
	}


	uint32 ringVertexCount = sliceCount + 1;

	for (uint32 i = 0; i < stackCount; ++i)
	{
		for (uint32 j = 0; j < sliceCount; ++j)
		{
			meshData.Indices32.push_back(i*ringVertexCount + j);
			meshData.Indices32.push_back((i + 1)*ringVertexCount + j);
			meshData.Indices32.push_back((i + 1)*ringVertexCount + j + 1);

			meshData.Indices32.push_back(i*ringVertexCount + j);
			meshData.Indices32.push_back((i + 1)*ringVertexCount + j + 1);
			meshData.Indices32.push_back(i*ringVertexCount + j + 1);
		}
	}

	BuildCylinderTopCap(bottomRadius, topRadius, height, sliceCount, stackCount, meshData);
	BuildCylinderBottomCap(bottomRadius, topRadius, height, sliceCount, stackCount, meshData);

	return meshData;
}

每一个环最后一个顶点与第一个顶点是重合的,但是纹理坐标不同,只有这样才能保证绘制正确纹理

构建顶部和底部

void GeometryGenerator::BuildCylinderTopCap(float bottomRadius, float topRadius, float height, uint32 sliceCount, uint32 stackCount, MeshData& meshData)
{
	uint32 baseIndex = (uint32)meshData.Vertices.size();

	float y = 0.5f*height;
	float dTheta = 2.0f*XM_PI / sliceCount;

	//顶点重复，因为纹理坐标和法线不同。
	for (uint32 i = 0; i <= sliceCount; ++i)
	{
		float x = topRadius * cosf(i*dTheta);
		float z = topRadius * sinf(i*dTheta);

		//按高度缩小以尝试使顶盖纹理坐标区域与底面成比例？？
		float u = x / height + 0.5f;
		float v = z / height + 0.5f;

		meshData.Vertices.push_back(Vertex(x, y, z, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, u, v));
	}

	// 中心点
	meshData.Vertices.push_back(Vertex(0.0f, y, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.5f, 0.5f));

	// 中心序号
	uint32 centerIndex = (uint32)meshData.Vertices.size() - 1;

	for (uint32 i = 0; i < sliceCount; ++i)
	{
		meshData.Indices32.push_back(centerIndex);
		meshData.Indices32.push_back(baseIndex + i + 1);
		meshData.Indices32.push_back(baseIndex + i);
	}
}

void GeometryGenerator::BuildCylinderBottomCap(float bottomRadius, float topRadius, float height, uint32 sliceCount, uint32 stackCount, MeshData& meshData)
{
	uint32 baseIndex = (uint32)meshData.Vertices.size();
	float y = -0.5f*height;


	float dTheta = 2.0f*XM_PI / sliceCount;
	for (uint32 i = 0; i <= sliceCount; ++i)
	{
		float x = bottomRadius * cosf(i*dTheta);
		float z = bottomRadius * sinf(i*dTheta);


		float u = x / height + 0.5f;
		float v = z / height + 0.5f;

		meshData.Vertices.push_back(Vertex(x, y, z, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, u, v));
	}


	meshData.Vertices.push_back(Vertex(0.0f, y, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.5f, 0.5f));

	uint32 centerIndex = (uint32)meshData.Vertices.size() - 1;

	for (uint32 i = 0; i < sliceCount; ++i)
	{
		meshData.Indices32.push_back(centerIndex);
		meshData.Indices32.push_back(baseIndex + i);
		meshData.Indices32.push_back(baseIndex + i + 1);
	}
}

几何球体

GeometryGenerator::MeshData GeometryGenerator::CreateGeosphere(float radius, uint32 numSubdivisions)
{
    MeshData meshData;

	// 为细分数设置上限。
    numSubdivisions = std::min<uint32>(numSubdivisions, 6u);

	// 通过镶嵌二十面体来近似一个球体。

	const float X = 0.525731f; 
	const float Z = 0.850651f;

	XMFLOAT3 pos[12] = 
	{
		XMFLOAT3(-X, 0.0f, Z),  XMFLOAT3(X, 0.0f, Z),  
		XMFLOAT3(-X, 0.0f, -Z), XMFLOAT3(X, 0.0f, -Z),    
		XMFLOAT3(0.0f, Z, X),   XMFLOAT3(0.0f, Z, -X), 
		XMFLOAT3(0.0f, -Z, X),  XMFLOAT3(0.0f, -Z, -X),    
		XMFLOAT3(Z, X, 0.0f),   XMFLOAT3(-Z, X, 0.0f), 
		XMFLOAT3(Z, -X, 0.0f),  XMFLOAT3(-Z, -X, 0.0f)
	};

    uint32 k[60] =
	{
		1,4,0,  4,9,0,  4,5,9,  8,5,4,  1,8,4,    
		1,10,8, 10,3,8, 8,3,5,  3,2,5,  3,7,2,    
		3,10,7, 10,6,7, 6,11,7, 6,0,11, 6,1,0, 
		10,1,6, 11,0,9, 2,11,9, 5,2,9,  11,2,7 
	};

    meshData.Vertices.resize(12);
    meshData.Indices32.assign(&k[0], &k[60]);

	for(uint32 i = 0; i < 12; ++i)
		meshData.Vertices[i].Position = pos[i];

	for(uint32 i = 0; i < numSubdivisions; ++i)
		Subdivide(meshData);

	//将顶点投影到球体和比例上。
	for(uint32 i = 0; i < meshData.Vertices.size(); ++i)
	{
		// 投影到单位球体上。
		XMVECTOR n = XMVector3Normalize(XMLoadFloat3(&meshData.Vertices[i].Position));

		// 投影到球体上。
		XMVECTOR p = radius*n;

		XMStoreFloat3(&meshData.Vertices[i].Position, p);
		XMStoreFloat3(&meshData.Vertices[i].Normal, n);

		// 从球坐标导出纹理坐标。
        float theta = atan2f(meshData.Vertices[i].Position.z, meshData.Vertices[i].Position.x);

        // 输入[0，2pi]。
        if(theta < 0.0f)
            theta += XM_2PI;

		float phi = acosf(meshData.Vertices[i].Position.y / radius);

		meshData.Vertices[i].TexC.x = theta/XM_2PI;
		meshData.Vertices[i].TexC.y = phi/XM_PI;

		// P关于theta的偏导数
		meshData.Vertices[i].TangentU.x = -radius*sinf(phi)*sinf(theta);
		meshData.Vertices[i].TangentU.y = 0.0f;
		meshData.Vertices[i].TangentU.z = +radius*sinf(phi)*cosf(theta);

		XMVECTOR T = XMLoadFloat3(&meshData.Vertices[i].TangentU);
		XMStoreFloat3(&meshData.Vertices[i].TangentU, XMVector3Normalize(T));
	}

    return meshData;
}

绘制几何体示例

我们已经创建一个由FrameResource类型元素所构成的向量，每个FrameReousrce中都有上传缓冲区，用于为场景中每一个渲染项存储渲染过程常量和物体常量数据。

如果有3个帧资源和n个渲染项，那么我们需要创建3n个物体常量缓冲区（object constant buffer）以及3个渲染过程常量缓冲区（pass 从constant buffer），因此我们需要创建3(n+1)个常量缓冲区视图。所以我们要修改CBV堆以容纳额外的描述符

#include "../Common/UploadBuffer.h"
#include "DXApp.h"
#include "../Common/MathHelper.h"
#include "GeometryGenerator.h"
#include "FrameResource.h"

using Microsoft::WRL::ComPtr;
using namespace DirectX;
using namespace DirectX::PackedVector;

const int gNumFrameResources = 3;

struct RenderItem
{
	RenderItem() = default;

	// 描述了局部空间相对于世界空间的矩阵
	//定义了物体位于世界空间的位置,朝向和大小
	XMFLOAT4X4 World = MathHelper::Identity4x4();

	// 用dirty flag来标志物体的相关数据已经发生改变,意味着我们次数需要更新常量缓冲区
	// 由于每个帧资源中都有一个物体常量缓冲区,所以需要对每个帧资源进行更新
	//即,当修改物体数据时,应当按NumFramesDirty= gNumFrameReousreces进行设置,从而使每个帧资源都更新
	int NumFramesDirty = gNumFrameResources;

	//索引到此渲染项目对应于ObjectCB的GPU常量缓冲区。
	UINT ObjCBIndex = -1;

	MeshGeometry* Geo = nullptr;

	//图元拓扑
	D3D12_PRIMITIVE_TOPOLOGY PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;

	// DrawIndexedInstanced方法的参数
	UINT IndexCount = 0;
	UINT StartIndexLocation = 0;
	int BaseVertexLocation = 0;
};


class ShapesApp : public DXApp
{
public:
	ShapesApp(HINSTANCE hInstance);
	ShapesApp(const ShapesApp& rhs) = delete;
	ShapesApp& operator=(const ShapesApp& rhs) = delete;
	~ShapesApp();
	virtual bool Initialize()override;

private:
	virtual void OnResize()override;
	virtual void Update(const GameTimer& gt)override;
	virtual void Draw(const GameTimer& gt)override;

	virtual void OnMouseDown(WPARAM btnState, int x, int y)override;
	virtual void OnMouseUp(WPARAM btnState, int x, int y)override;
	virtual void OnMouseMove(WPARAM btnState, int x, int y)override;

	void OnKeyboardInput(const GameTimer& gt);
	void UpdateCamera(const GameTimer& gt);
	void UpdateObjectCBs(const GameTimer& gt);
	void UpdateMainPassCB(const GameTimer& gt);

	void BuildDescriptorHeaps();
	void BuildConstantBufferViews();
	void BuildRootSignature();
	void BuildShadersAndInputLayout();
	void BuildShapeGeometry();
	void BuildPSOs();
	void BuildFrameResources();
	void BuildRenderItems();
	void DrawRenderItems(ID3D12GraphicsCommandList* cmdList, const std::vector<RenderItem*>& ritems);

private:

	std::vector<std::unique_ptr<FrameResource>> mFrameResources;//帧资源数组
	FrameResource* mCurrFrameResource = nullptr;//当前帧资源
	int mCurrFrameResourceIndex = 0;//当前帧资源序号

	ComPtr<ID3D12RootSignature> mRootSignature = nullptr;//根签名
	ComPtr<ID3D12DescriptorHeap> mCbvHeap = nullptr;
	ComPtr<ID3D12DescriptorHeap> mSrvDescriptorHeap = nullptr;

	std::unordered_map<std::string, std::unique_ptr<MeshGeometry>> mGeometries;//几何体哈希表
	std::unordered_map<std::string, ComPtr<ID3DBlob>> mShaders;//着色器表
	std::unordered_map<std::string, ComPtr<ID3D12PipelineState>> mPSOs;//流水线对象表

	std::vector<D3D12_INPUT_ELEMENT_DESC> mInputLayout;

	std::vector<std::unique_ptr<RenderItem>> mAllRitems;

	std::vector<RenderItem*> mOpaqueRitems;

	PassConstants mMainPassCB;

	UINT mPassCbvOffset = 0;

	bool mIsWireframe = false;

	XMFLOAT3 mEyePos = { 0.0f, 0.0f, 0.0f };
	XMFLOAT4X4 mView = MathHelper::Identity4x4();
	XMFLOAT4X4 mProj = MathHelper::Identity4x4();

	float mTheta = 1.5f*XM_PI;
	float mPhi = 0.2f*XM_PI;
	float mRadius = 15.0f;

	POINT mLastMousePos;
};

ShapesApp::ShapesApp(HINSTANCE hInstance):DXApp(hInstance)
{

}

ShapesApp::~ShapesApp()
{
	if (md3dDevice!=nullptr)
	{
		FlushCommandQueue();
	}
}

bool ShapesApp::Initialize()
{
	if (!DXApp::Initialize())
	{
		return false;
	}


	ThrowIfFailed(mCommandList->Reset(mDirectCmdListAlloc.Get(), nullptr));

	BuildRootSignature();
	BuildShadersAndInputLayout();
	BuildShapeGeometry();
	BuildRenderItems();
	BuildFrameResources();
	BuildDescriptorHeaps();
	BuildConstantBufferViews();
	BuildPSOs();

	ThrowIfFailed(mCommandList->Close());
	ID3D12CommandList* cmdsLists[] = { mCommandList.Get() };
	mCommandQueue->ExecuteCommandLists(_countof(cmdsLists), cmdsLists);

	FlushCommandQueue();

	return true;



	return true;
}




void ShapesApp::OnResize()
{
	DXApp::OnResize();


	XMMATRIX P = XMMatrixPerspectiveFovLH(0.25f*MathHelper::Pi, AspectRatio(), 1.0f, 1000.0f);
	XMStoreFloat4x4(&mProj, P);
}

void ShapesApp::Update(const GameTimer & gt)
{
	OnKeyboardInput(gt);
	UpdateCamera(gt);
	mCurrFrameResourceIndex = (mCurrFrameResourceIndex + 1) % gNumFrameResources;
	mCurrFrameResource = mFrameResources[mCurrFrameResourceIndex].get();

	//GPU是否执行完所有命令?
   //如果还没有就令CPU等待,直到GPU完成所有命令的执行并且抵达这个围栏点
	if (mCurrFrameResource->Fence != 0 && mFence->GetCompletedValue() < mCurrFrameResource->Fence)
	{
		HANDLE eventHandle = CreateEventEx(nullptr, false, false, EVENT_ALL_ACCESS);
		ThrowIfFailed(mFence->SetEventOnCompletion(mCurrFrameResource->Fence, eventHandle));
		WaitForSingleObject(eventHandle, INFINITE);
		CloseHandle(eventHandle);
	}

	UpdateObjectCBs(gt);
	UpdateMainPassCB(gt);
}

void ShapesApp::Draw(const GameTimer & gt)
{
	auto cmdListAlloc = mCurrFrameResource->CmdListAlloc;

	// Reuse the memory associated with command recording.
	// We can only reset when the associated command lists have finished execution on the GPU.
	ThrowIfFailed(cmdListAlloc->Reset());

	// A command list can be reset after it has been added to the command queue via ExecuteCommandList.
	// Reusing the command list reuses memory.
	if (mIsWireframe)
	{
		ThrowIfFailed(mCommandList->Reset(cmdListAlloc.Get(), mPSOs["opaque_wireframe"].Get()));
	}
	else
	{
		ThrowIfFailed(mCommandList->Reset(cmdListAlloc.Get(), mPSOs["opaque"].Get()));
	}

	mCommandList->RSSetViewports(1, &mScreenViewport);
	mCommandList->RSSetScissorRects(1, &mScissorRect);

	// 指示资源使用情况的状态转换。
	mCommandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(CurrentBackBuffer(),
		D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET));

	// 清除后缓冲区和深度缓冲区。
	mCommandList->ClearRenderTargetView(CurrentBackBufferView(), Colors::LightSteelBlue, 0, nullptr);
	mCommandList->ClearDepthStencilView(DepthStencilView(), D3D12_CLEAR_FLAG_DEPTH | D3D12_CLEAR_FLAG_STENCIL, 1.0f, 0, 0, nullptr);

	// 指定我们要渲染到的缓冲区。
	mCommandList->OMSetRenderTargets(1, &CurrentBackBufferView(), true, &DepthStencilView());

	ID3D12DescriptorHeap* descriptorHeaps[] = { mCbvHeap.Get() };
	mCommandList->SetDescriptorHeaps(_countof(descriptorHeaps), descriptorHeaps);

	mCommandList->SetGraphicsRootSignature(mRootSignature.Get());

	int passCbvIndex = mPassCbvOffset + mCurrFrameResourceIndex;
	auto passCbvHandle = CD3DX12_GPU_DESCRIPTOR_HANDLE(mCbvHeap->GetGPUDescriptorHandleForHeapStart());
	passCbvHandle.Offset(passCbvIndex, mCbvSrvUavDescriptorSize);
	mCommandList->SetGraphicsRootDescriptorTable(1, passCbvHandle);

	DrawRenderItems(mCommandList.Get(), mOpaqueRitems);

	// 指示资源使用情况的状态转换。
	mCommandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(CurrentBackBuffer(),
		D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT));


	ThrowIfFailed(mCommandList->Close());
	ID3D12CommandList* cmdsLists[] = { mCommandList.Get() };
	mCommandQueue->ExecuteCommandLists(_countof(cmdsLists), cmdsLists);

	ThrowIfFailed(mSwapChain->Present(0, 0));
	mCurrBackBuffer = (mCurrBackBuffer + 1) % SwapChainBufferCount;

	// 扩展围栏值以将命令标记到该围栏点。
	mCurrFrameResource->Fence = ++mCurrentFence;

	// 将指令添加到命令队列以设置新的围栏点。
	//因为我们在GPU时间轴上，所以新的隔离点将不会
	//设置直到GPU完成处理此Signal（）之前的所有命令为止。
	mCommandQueue->Signal(mFence.Get(), mCurrentFence);
}

void ShapesApp::OnMouseDown(WPARAM btnState, int x, int y)
{
	mLastMousePos.x = x;
	mLastMousePos.y = y;

	SetCapture(mhMainWnd);
}

void ShapesApp::OnMouseUp(WPARAM btnState, int x, int y)
{

	ReleaseCapture();
}

void ShapesApp::OnMouseMove(WPARAM btnState, int x, int y)
{
	if ((btnState & MK_LBUTTON) != 0)
	{

		float dx = XMConvertToRadians(0.25f*static_cast<float>(x - mLastMousePos.x));
		float dy = XMConvertToRadians(0.25f*static_cast<float>(y - mLastMousePos.y));

		mTheta -= dx;
		mPhi -= dy;


		mPhi = MathHelper::Clamp(mPhi, 0.1f, MathHelper::Pi - 0.1f);
	}
	else if ((btnState & MK_RBUTTON) != 0)
	{

		float dx = 0.05f*static_cast<float>(x - mLastMousePos.x);
		float dy = 0.05f*static_cast<float>(y - mLastMousePos.y);

		mRadius += dx - dy;

		mRadius = MathHelper::Clamp(mRadius, 5.0f, 150.0f);
	}

	mLastMousePos.x = x;
	mLastMousePos.y = y;
}

void ShapesApp::OnKeyboardInput(const GameTimer& gt)
{
	if (GetAsyncKeyState('1') & 0x8000)
		mIsWireframe = true;
	else
		mIsWireframe = false;
}

void ShapesApp::UpdateCamera(const GameTimer& gt)
{
	mEyePos.x = mRadius * sinf(mPhi)*cosf(mTheta);
	mEyePos.z = mRadius * sinf(mPhi)*sinf(mTheta);
	mEyePos.y = mRadius * cosf(mPhi);

	// Build the view matrix.
	XMVECTOR pos = XMVectorSet(mEyePos.x, mEyePos.y, mEyePos.z, 1.0f);
	XMVECTOR target = XMVectorZero();
	XMVECTOR up = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);

	XMMATRIX view = XMMatrixLookAtLH(pos, target, up);
	XMStoreFloat4x4(&mView, view);
}

void ShapesApp::UpdateObjectCBs(const GameTimer& gt)
{

	auto currObjectCB = mCurrFrameResource->ObjectCB.get();
	for (auto& e : mAllRitems)
	{
		//仅在常量更改后才更新cbuffer数据。
		//需要针对每个框架资源进行跟踪。
		if (e->NumFramesDirty > 0)
		{
			XMMATRIX world = XMLoadFloat4x4(&e->World);

			ObjectConstants objConstants;
			XMStoreFloat4x4(&objConstants.World, XMMatrixTranspose(world));

			currObjectCB->CopyData(e->ObjCBIndex, objConstants);

		
			e->NumFramesDirty--;
		}
	}
}

void ShapesApp::UpdateMainPassCB(const GameTimer& gt)
{
	XMMATRIX view = XMLoadFloat4x4(&mView);
	XMMATRIX proj = XMLoadFloat4x4(&mProj);

	XMMATRIX viewProj = XMMatrixMultiply(view, proj);
	XMMATRIX invView = XMMatrixInverse(&XMMatrixDeterminant(view), view);
	XMMATRIX invProj = XMMatrixInverse(&XMMatrixDeterminant(proj), proj);
	XMMATRIX invViewProj = XMMatrixInverse(&XMMatrixDeterminant(viewProj), viewProj);

	XMStoreFloat4x4(&mMainPassCB.View, XMMatrixTranspose(view));
	XMStoreFloat4x4(&mMainPassCB.InvView, XMMatrixTranspose(invView));
	XMStoreFloat4x4(&mMainPassCB.Proj, XMMatrixTranspose(proj));
	XMStoreFloat4x4(&mMainPassCB.InvProj, XMMatrixTranspose(invProj));
	XMStoreFloat4x4(&mMainPassCB.ViewProj, XMMatrixTranspose(viewProj));
	XMStoreFloat4x4(&mMainPassCB.InvViewProj, XMMatrixTranspose(invViewProj));
	mMainPassCB.EyePosW = mEyePos;
	mMainPassCB.RenderTargetSize = XMFLOAT2((float)mClientWidth, (float)mClientHeight);
	mMainPassCB.InvRenderTargetSize = XMFLOAT2(1.0f / mClientWidth, 1.0f / mClientHeight);
	mMainPassCB.NearZ = 1.0f;
	mMainPassCB.FarZ = 1000.0f;
	mMainPassCB.TotalTime = gt.TotalTime();
	mMainPassCB.DeltaTime = gt.DeltaTime();

	auto currPassCB = mCurrFrameResource->PassCB.get();
	currPassCB->CopyData(0, mMainPassCB);
}
/*我们已经创建一个由FrameResource类型元素所构成的向量，每个FrameReousrce中都有上传缓冲区，用于为场景中每一个渲染项存储渲染过程常量和物体常量数据。

如果有3个帧资源和n个渲染项，那么我们需要创建3n个物体常量缓冲区（object constant buffer）以及3个渲染过程常量缓冲区（pass 从constant buffer），因此我们需要创建3(n+1)个常量缓冲区视图。所以我们要修改CBV堆以容纳额外的描述符*/
void ShapesApp::BuildDescriptorHeaps()
{
	UINT objCount = (UINT)mOpaqueRitems.size();
	//每个帧资源的每个对象都需要一个CBV描述符，每个帧资源的perPass CBV +1。
	UINT numDescriptors = (objCount+1)*gNumFrameResources;
	//将偏移量保存到通过CBV的起点。 这是最后3个描述符。
	mPassCbvOffset=objCount*gNumFrameResources;

	//创建描述符堆
	D3D12_DESCRIPTOR_HEAP_DESC cbvHeapDesc;
	cbvHeapDesc.NumDescriptors = numDescriptors;
	cbvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
	cbvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
	cbvHeapDesc.NodeMask = 0;
	ThrowIfFailed(md3dDevice->CreateDescriptorHeap(&cbvHeapDesc,
		IID_PPV_ARGS(&mCbvHeap)));

}
//我们可以使用下列代码来填充CBV堆了，其中0-n-1描述符为第0个帧资源的物体CBV……3n、3n + 1、3n + 2分别为帧资源的渲染过程CBV
void ShapesApp::BuildConstantBufferViews()
{
	UINT objCBByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(ObjectConstants));

	UINT objCount = (UINT)mOpaqueRitems.size();
	//每个帧资源的每个对象都需要一个CBV描述符。
	for (int frameIndex = 0; frameIndex < gNumFrameResources; ++frameIndex)
	{
		auto objectCB = mFrameResources[frameIndex]->ObjectCB->Resource();
		for (UINT i = 0; i < objCount; ++i)
		{
			D3D12_GPU_VIRTUAL_ADDRESS cbAddress = objectCB->GetGPUVirtualAddress();

			//缓冲区中第i个对象常量缓冲区的偏移量。
			cbAddress += i * objCBByteSize;

			//偏移量到描述符堆中的对象cbv。
			int heapIndex = frameIndex * objCount + i;
			auto handle = CD3DX12_CPU_DESCRIPTOR_HANDLE(mCbvHeap->GetCPUDescriptorHandleForHeapStart());
            //通过调用ID3D12DescriptorHeap::GetCPUDescriptorHandleForHeapStart方法可以获得堆中的第一个描述符的句柄，但是现在堆中存储的不是一个描述符了，如果想要访问到堆中的其他描述符，必须进行偏移
			handle.Offset(heapIndex, mCbvSrvUavDescriptorSize);

			D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc;
			cbvDesc.BufferLocation = cbAddress;
			cbvDesc.SizeInBytes = objCBByteSize;

			md3dDevice->CreateConstantBufferView(&cbvDesc, handle);
		}
	}

	UINT passCBByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(PassConstants));

	//最后三个描述符是每个帧资源的传递CBV。
	for (int frameIndex = 0; frameIndex < gNumFrameResources; ++frameIndex)
	{
		auto passCB = mFrameResources[frameIndex]->PassCB->Resource();
		D3D12_GPU_VIRTUAL_ADDRESS cbAddress = passCB->GetGPUVirtualAddress();

		// 偏移到描述符堆中的传递cbv。
		int heapIndex = mPassCbvOffset + frameIndex;
		auto handle = CD3DX12_CPU_DESCRIPTOR_HANDLE(mCbvHeap->GetCPUDescriptorHandleForHeapStart());
		handle.Offset(heapIndex, mCbvSrvUavDescriptorSize);

		D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc;
		cbvDesc.BufferLocation = cbAddress;
		cbvDesc.SizeInBytes = passCBByteSize;

		md3dDevice->CreateConstantBufferView(&cbvDesc, handle);
	}
}

void ShapesApp::BuildRootSignature()
{
	// 创建2个描述
	CD3DX12_DESCRIPTOR_RANGE cbvTable0;
	cbvTable0.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0);

	CD3DX12_DESCRIPTOR_RANGE cbvTable1;
	cbvTable1.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 1);

	// 2个成员的描述符表
	CD3DX12_ROOT_PARAMETER slotRootParameter[2];

	// Create root CBVs.
	slotRootParameter[0].InitAsDescriptorTable(1, &cbvTable0);
	slotRootParameter[1].InitAsDescriptorTable(1, &cbvTable1);

	// 创建根CBV
	CD3DX12_ROOT_SIGNATURE_DESC rootSigDesc(2, slotRootParameter, 0, nullptr,
		D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);

	ComPtr<ID3DBlob> serializedRootSig = nullptr;
	ComPtr<ID3DBlob> errorBlob = nullptr;
	HRESULT hr = D3D12SerializeRootSignature(&rootSigDesc, D3D_ROOT_SIGNATURE_VERSION_1,
		serializedRootSig.GetAddressOf(), errorBlob.GetAddressOf());

	if (errorBlob != nullptr)
	{
		::OutputDebugStringA((char*)errorBlob->GetBufferPointer());
	}
	ThrowIfFailed(hr);

	ThrowIfFailed(md3dDevice->CreateRootSignature(
		0,
		serializedRootSig->GetBufferPointer(),
		serializedRootSig->GetBufferSize(),
		IID_PPV_ARGS(mRootSignature.GetAddressOf())));
}

void ShapesApp::BuildShadersAndInputLayout()
{
	mShaders["standardVS"] = d3dUtil::CompileShader(L"Shaders\\color7.hlsl", nullptr, "VS", "vs_5_1");
	mShaders["opaquePS"] = d3dUtil::CompileShader(L"Shaders\\color7.hlsl", nullptr, "PS", "ps_5_1");

	mInputLayout =
	{
		{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
		{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
	};
}

void ShapesApp::BuildShapeGeometry()
{
	GeometryGenerator geoGen;
	GeometryGenerator::MeshData box = geoGen.CreateBox(1.5f, 0.5f, 1.5f, 3);
	GeometryGenerator::MeshData grid = geoGen.CreateGrid(20.0f, 30.0f, 60, 40);
	GeometryGenerator::MeshData sphere = geoGen.CreateSphere(0.5f, 20, 20);
	GeometryGenerator::MeshData cylinder = geoGen.CreateCylinder(0.5f, 0.3f, 3.0f, 20, 20);

	//顶点偏移量缓存到级联的顶点缓冲区中的每个对象。
	UINT boxVertexOffset = 0;
	UINT gridVertexOffset = (UINT)box.Vertices.size();
	UINT sphereVertexOffset = gridVertexOffset + (UINT)grid.Vertices.size();
	UINT cylinderVertexOffset = sphereVertexOffset + (UINT)sphere.Vertices.size();
	//将每个对象的起始索引缓存在串联索引缓冲区中。
	UINT boxIndexOffset = 0;
	UINT gridIndexOffset = (UINT)box.Indices32.size();
	UINT sphereIndexOffset = gridIndexOffset + (UINT)grid.Indices32.size();
	UINT cylinderIndexOffset = sphereIndexOffset + (UINT)sphere.Indices32.size();

	SubmeshGeometry boxSubmesh;
	boxSubmesh.IndexCount = (UINT)box.Indices32.size();
	boxSubmesh.StartIndexLocation = boxIndexOffset;
	boxSubmesh.BaseVertexLocation = boxVertexOffset;

	SubmeshGeometry gridSubmesh;
	gridSubmesh.IndexCount = (UINT)grid.Indices32.size();
	gridSubmesh.StartIndexLocation = gridIndexOffset;
	gridSubmesh.BaseVertexLocation = gridVertexOffset;

	SubmeshGeometry sphereSubmesh;
	sphereSubmesh.IndexCount = (UINT)sphere.Indices32.size();
	sphereSubmesh.StartIndexLocation = sphereIndexOffset;
	sphereSubmesh.BaseVertexLocation = sphereVertexOffset;

	SubmeshGeometry cylinderSubmesh;
	cylinderSubmesh.IndexCount = (UINT)cylinder.Indices32.size();
	cylinderSubmesh.StartIndexLocation = cylinderIndexOffset;
	cylinderSubmesh.BaseVertexLocation = cylinderVertexOffset;

	//顶点数总计
	auto totalVertexCount =
		box.Vertices.size() +
		grid.Vertices.size() +
		sphere.Vertices.size() +
		cylinder.Vertices.size();

	std::vector<Vertex> vertices(totalVertexCount);

	//添加所有顶点和颜色数据
	UINT k = 0;
	for (size_t i = 0; i < box.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos = box.Vertices[i].Position;
		vertices[k].Color = XMFLOAT4(DirectX::Colors::Blue);
	}

	for (size_t i = 0; i < grid.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos = grid.Vertices[i].Position;
		vertices[k].Color = XMFLOAT4(DirectX::Colors::ForestGreen);
	}

	for (size_t i = 0; i < sphere.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos = sphere.Vertices[i].Position;
		vertices[k].Color = XMFLOAT4(DirectX::Colors::Crimson);
	}

	for (size_t i = 0; i < cylinder.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos = cylinder.Vertices[i].Position;
		vertices[k].Color = XMFLOAT4(DirectX::Colors::SteelBlue);
	}

	//添加所有索引
	std::vector<std::uint16_t> indices;
	indices.insert(indices.end(), std::begin(box.GetIndices16()), std::end(box.GetIndices16()));
	indices.insert(indices.end(), std::begin(grid.GetIndices16()), std::end(grid.GetIndices16()));
	indices.insert(indices.end(), std::begin(sphere.GetIndices16()), std::end(sphere.GetIndices16()));
	indices.insert(indices.end(), std::begin(cylinder.GetIndices16()), std::end(cylinder.GetIndices16()));

	const UINT vbByteSize = (UINT)vertices.size() * sizeof(Vertex);
	const UINT ibByteSize = (UINT)indices.size() * sizeof(std::uint16_t);

	auto geo = std::make_unique<MeshGeometry>();
	geo->Name = "shapeGeo";

	ThrowIfFailed(D3DCreateBlob(vbByteSize, &geo->VertexBufferCPU));
	CopyMemory(geo->VertexBufferCPU->GetBufferPointer(), vertices.data(), vbByteSize);

	ThrowIfFailed(D3DCreateBlob(ibByteSize, &geo->IndexBufferCPU));
	CopyMemory(geo->IndexBufferCPU->GetBufferPointer(), indices.data(), ibByteSize);

	geo->VertexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), vertices.data(), vbByteSize, geo->VertexBufferUploader);

	geo->IndexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), indices.data(), ibByteSize, geo->IndexBufferUploader);


	geo->VertexByteStride = sizeof(Vertex);
	geo->VertexBufferByteSize = vbByteSize;
	geo->IndexFormat = DXGI_FORMAT_R16_UINT;
	geo->IndexBufferByteSize = ibByteSize;

	geo->DrawArgs["box"] = boxSubmesh;
	geo->DrawArgs["grid"] = gridSubmesh;
	geo->DrawArgs["sphere"] = sphereSubmesh;
	geo->DrawArgs["cylinder"] = cylinderSubmesh;

	mGeometries[geo->Name] = std::move(geo);
}

void ShapesApp::BuildPSOs()
{
	D3D12_GRAPHICS_PIPELINE_STATE_DESC opaquePsoDesc;


	ZeroMemory(&opaquePsoDesc, sizeof(D3D12_GRAPHICS_PIPELINE_STATE_DESC));
	opaquePsoDesc.InputLayout = { mInputLayout.data(), (UINT)mInputLayout.size() };
	opaquePsoDesc.pRootSignature = mRootSignature.Get();
	opaquePsoDesc.VS =
	{
		reinterpret_cast<BYTE*>(mShaders["standardVS"]->GetBufferPointer()),
		mShaders["standardVS"]->GetBufferSize()
	};
	opaquePsoDesc.PS =
	{
		reinterpret_cast<BYTE*>(mShaders["opaquePS"]->GetBufferPointer()),
		mShaders["opaquePS"]->GetBufferSize()
	};
	opaquePsoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT);
	opaquePsoDesc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
	opaquePsoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT);
	opaquePsoDesc.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT);
	opaquePsoDesc.SampleMask = UINT_MAX;
	opaquePsoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
	opaquePsoDesc.NumRenderTargets = 1;
	opaquePsoDesc.RTVFormats[0] = mBackBufferFormat;
	opaquePsoDesc.SampleDesc.Count = m4xMsaaState ? 4 : 1;
	opaquePsoDesc.SampleDesc.Quality = m4xMsaaState ? (m4xMsaaQuality - 1) : 0;
	opaquePsoDesc.DSVFormat = mDepthStencilFormat;
	ThrowIfFailed(md3dDevice->CreateGraphicsPipelineState(&opaquePsoDesc, IID_PPV_ARGS(&mPSOs["opaque"])));


	D3D12_GRAPHICS_PIPELINE_STATE_DESC opaqueWireframePsoDesc = opaquePsoDesc;
	opaqueWireframePsoDesc.RasterizerState.FillMode = D3D12_FILL_MODE_WIREFRAME;//网格显示
	ThrowIfFailed(md3dDevice->CreateGraphicsPipelineState(&opaqueWireframePsoDesc, IID_PPV_ARGS(&mPSOs["opaque_wireframe"])));
}

void ShapesApp::BuildFrameResources()
{
	for (int i = 0; i < gNumFrameResources; ++i)
	{
		mFrameResources.push_back(std::make_unique<FrameResource>(md3dDevice.Get(),
			1, (UINT)mAllRitems.size()));
	}
}

void ShapesApp::BuildRenderItems()
{
	auto boxRitem = std::make_unique<RenderItem>();
	XMStoreFloat4x4(&boxRitem->World, XMMatrixScaling(2.0f, 2.0f, 2.0f)*XMMatrixTranslation(0.0f, 0.5f, 0.0f));
	boxRitem->ObjCBIndex = 0;
	boxRitem->Geo = mGeometries["shapeGeo"].get();
	boxRitem->PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
	boxRitem->IndexCount = boxRitem->Geo->DrawArgs["box"].IndexCount;
	boxRitem->StartIndexLocation = boxRitem->Geo->DrawArgs["box"].StartIndexLocation;
	boxRitem->BaseVertexLocation = boxRitem->Geo->DrawArgs["box"].BaseVertexLocation;
	mAllRitems.push_back(std::move(boxRitem));

	auto gridRitem = std::make_unique<RenderItem>();
	gridRitem->World = MathHelper::Identity4x4();
	gridRitem->ObjCBIndex = 1;
	gridRitem->Geo = mGeometries["shapeGeo"].get();
	gridRitem->PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
	gridRitem->IndexCount = gridRitem->Geo->DrawArgs["grid"].IndexCount;
	gridRitem->StartIndexLocation = gridRitem->Geo->DrawArgs["grid"].StartIndexLocation;
	gridRitem->BaseVertexLocation = gridRitem->Geo->DrawArgs["grid"].BaseVertexLocation;
	mAllRitems.push_back(std::move(gridRitem));

	UINT objCBIndex = 2;
	for (int i = 0; i < 5; ++i)
	{
		auto leftCylRitem = std::make_unique<RenderItem>();
		auto rightCylRitem = std::make_unique<RenderItem>();
		auto leftSphereRitem = std::make_unique<RenderItem>();
		auto rightSphereRitem = std::make_unique<RenderItem>();

		XMMATRIX leftCylWorld = XMMatrixTranslation(-5.0f, 1.5f, -10.0f + i * 5.0f);
		XMMATRIX rightCylWorld = XMMatrixTranslation(+5.0f, 1.5f, -10.0f + i * 5.0f);

		XMMATRIX leftSphereWorld = XMMatrixTranslation(-5.0f, 3.5f, -10.0f + i * 5.0f);
		XMMATRIX rightSphereWorld = XMMatrixTranslation(+5.0f, 3.5f, -10.0f + i * 5.0f);

		XMStoreFloat4x4(&leftCylRitem->World, rightCylWorld);
		leftCylRitem->ObjCBIndex = objCBIndex++;
		leftCylRitem->Geo = mGeometries["shapeGeo"].get();
		leftCylRitem->PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
		leftCylRitem->IndexCount = leftCylRitem->Geo->DrawArgs["cylinder"].IndexCount;
		leftCylRitem->StartIndexLocation = leftCylRitem->Geo->DrawArgs["cylinder"].StartIndexLocation;
		leftCylRitem->BaseVertexLocation = leftCylRitem->Geo->DrawArgs["cylinder"].BaseVertexLocation;

		XMStoreFloat4x4(&rightCylRitem->World, leftCylWorld);
		rightCylRitem->ObjCBIndex = objCBIndex++;
		rightCylRitem->Geo = mGeometries["shapeGeo"].get();
		rightCylRitem->PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
		rightCylRitem->IndexCount = rightCylRitem->Geo->DrawArgs["cylinder"].IndexCount;
		rightCylRitem->StartIndexLocation = rightCylRitem->Geo->DrawArgs["cylinder"].StartIndexLocation;
		rightCylRitem->BaseVertexLocation = rightCylRitem->Geo->DrawArgs["cylinder"].BaseVertexLocation;

		XMStoreFloat4x4(&leftSphereRitem->World, leftSphereWorld);
		leftSphereRitem->ObjCBIndex = objCBIndex++;
		leftSphereRitem->Geo = mGeometries["shapeGeo"].get();
		leftSphereRitem->PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
		leftSphereRitem->IndexCount = leftSphereRitem->Geo->DrawArgs["sphere"].IndexCount;
		leftSphereRitem->StartIndexLocation = leftSphereRitem->Geo->DrawArgs["sphere"].StartIndexLocation;
		leftSphereRitem->BaseVertexLocation = leftSphereRitem->Geo->DrawArgs["sphere"].BaseVertexLocation;

		XMStoreFloat4x4(&rightSphereRitem->World, rightSphereWorld);
		rightSphereRitem->ObjCBIndex = objCBIndex++;
		rightSphereRitem->Geo = mGeometries["shapeGeo"].get();
		rightSphereRitem->PrimitiveType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
		rightSphereRitem->IndexCount = rightSphereRitem->Geo->DrawArgs["sphere"].IndexCount;
		rightSphereRitem->StartIndexLocation = rightSphereRitem->Geo->DrawArgs["sphere"].StartIndexLocation;
		rightSphereRitem->BaseVertexLocation = rightSphereRitem->Geo->DrawArgs["sphere"].BaseVertexLocation;

		mAllRitems.push_back(std::move(leftCylRitem));
		mAllRitems.push_back(std::move(rightCylRitem));
		mAllRitems.push_back(std::move(leftSphereRitem));
		mAllRitems.push_back(std::move(rightSphereRitem));
	}

	// All the render items are opaque.
	for (auto& e : mAllRitems)
		mOpaqueRitems.push_back(e.get());
}
//在该步骤中，最复杂的一个部分便是为了绘制物体而根据偏移量找到它在描述符堆中对应的CBV了：
void ShapesApp::DrawRenderItems(ID3D12GraphicsCommandList* cmdList, const std::vector<RenderItem*>& ritems)
{
	UINT objCBByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(ObjectConstants));

	auto objectCB = mCurrFrameResource->ObjectCB->Resource();
	//遍历RenderItem
	for (size_t i = 0; i < ritems.size(); ++i)
	{
		auto ri = ritems[i];

		cmdList->IASetVertexBuffers(0, 1, &ri->Geo->VertexBufferView());
		cmdList->IASetIndexBuffer(&ri->Geo->IndexBufferView());
		cmdList->IASetPrimitiveTopology(ri->PrimitiveType);

		// 此对象和此帧资源的描述符堆中的CBV偏移。
		UINT cbvIndex = mCurrFrameResourceIndex * (UINT)mOpaqueRitems.size() + ri->ObjCBIndex;
		auto cbvHandle = CD3DX12_GPU_DESCRIPTOR_HANDLE(mCbvHeap->GetGPUDescriptorHandleForHeapStart());
		cbvHandle.Offset(cbvIndex, mCbvSrvUavDescriptorSize);

		cmdList->SetGraphicsRootDescriptorTable(0, cbvHandle);

		cmdList->DrawIndexedInstanced(ri->IndexCount, 1, ri->StartIndexLocation, ri->BaseVertexLocation, 0);
	}
}

int WINAPI WinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPSTR lpCmdLine, _In_ int nShowCmd)
{


#if defined(DEBUG) | defined(_DEBUG)
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif

	try
	{
		ShapesApp theApp(hInstance);
		if (!theApp.Initialize())
			return 0;

		return theApp.Run();
	}
	catch (DxException& e)
	{
		MessageBox(nullptr, e.ToString().c_str(), L"HR Failed", MB_OK);
		return 0;
	}



}

根签名

根参数

typedef struct D3D12_ROOT_PARAMETER
    {
    D3D12_ROOT_PARAMETER_TYPE ParameterType;
    union 
        {
        D3D12_ROOT_DESCRIPTOR_TABLE DescriptorTable;//指定类型,如描述符表,根常量,CBV,SRV,UAV
        D3D12_ROOT_CONSTANTS Constants;
        D3D12_ROOT_DESCRIPTOR Descriptor;
        } 	;
    D3D12_SHADER_VISIBILITY ShaderVisibility;//指定着色器可见性
    } 	D3D12_ROOT_PARAMETER;

typedef 
enum D3D12_ROOT_PARAMETER_TYPE
    {
        D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE	= 0,
        D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS	= ( D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE + 1 ) ,
        D3D12_ROOT_PARAMETER_TYPE_CBV	= ( D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS + 1 ) ,
        D3D12_ROOT_PARAMETER_TYPE_SRV	= ( D3D12_ROOT_PARAMETER_TYPE_CBV + 1 ) ,
        D3D12_ROOT_PARAMETER_TYPE_UAV	= ( D3D12_ROOT_PARAMETER_TYPE_SRV + 1 ) 
    } 	D3D12_ROOT_PARAMETER_TYPE;

描述符表:引用的是描述符堆种的一块连续范围,用于确定要绑定的资源.每个描述符表占用1DWORD
跟描述符:通过直接设置跟描述符即可指示要绑定的资源,而且无需将它存于描述符中,但是只有常量缓冲区CBV,以及缓冲区的SRV/UAV才可以根据描述符的身份进行绑定.而纹理SRV不可以.每个描述符占用2DWORD
根常量:借助根常量直接绑定一系列的32位的常量值.每个常量32位,占用1个DWORD

描述符表

typedef struct D3D12_DESCRIPTOR_RANGE
    {
    D3D12_DESCRIPTOR_RANGE_TYPE RangeType;//类型,如...SRV,...CBV
    UINT NumDescriptors;//描述符的数量
    UINT BaseShaderRegister;//绑定的寄存器槽
    UINT RegisterSpace;//空间,默认=0
    UINT OffsetInDescriptorsFromTableStart;//此描述符距离表其实地址的偏移量
    }

CD3D12_DESCRIPTOR_RANGE是封装了一些便捷方法,通过Init方法初始化

如果NumDescriptors设置为3,BaseShaderRegister设置为1,类型为CBV,那么对应的HLSL就是

1
2
3

cbuffer cbA : register(b1){};//从1开始
cbuffer cbB : register(b2){};
cbuffer cbC : register(b3){};

示例

CD3DX12_DESCRIPTOR_RANGE descRange[3];
descRange[0].Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 2, 0, 0);
descRange[1].Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 3, 0, 2/*起始偏移量*/);
descRange[2].Init(D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 1, 0, 5/*起始偏移量*/);

slotRootParameter[0].InitAsDescriptorTable(3, descRange, D3D12_SHADER_VISIBILITY_ALL);

根描述符

填写D3D12_ROOT_PARAMETER中的Descriptor,可以定义为根描述符

typedef struct D3D12_ROOT_DESCRIPTOR
    {
    UINT ShaderRegister;
    UINT RegisterSpace;
    } 	D3D12_ROOT_DESCRIPTOR;

ShaderRegister:如果设置为2,类型为CBV,那么对应的常量缓冲区是register(b2)
RegisterSpace:空间

与描述符表需要在描述符堆中设置对应的描述符句柄不同,根描述符只需要直接绑定资源的虚拟地址就可以

示例

UINT objCBByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(ObjectConstants));
D3D12_GPU_VIRTUAL_ADDRESS objCBAddress = objectCB->GetGPUVirtualAddress();
objCBAddress += ri->ObjCBIndex*objCBByteSize;
cmdList->SetGraphicsRootConstantBufferView(0, objCBAddress);

根常量

typedef struct D3D12_ROOT_CONSTANTS
    {
    UINT ShaderRegister;
    UINT RegisterSpace;
    UINT Num32BitValues;//根常量所需的32位常量的个数
    } 	D3D12_ROOT_CONSTANTS;

示例

CD3DX12_ROOT_PARAMETER slotRootParameter[1];
slotRootParameter[0].InitAsConstants(12,0);

	CD3DX12_ROOT_SIGNATURE_DESC rootSigDesc(1, slotRootParameter, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
//应用程序部分
auto weights = CalcGaussWeights(2.5f);
int blurRadius = (int)weights.size()/2;
 
cmdList->SetGraphicsRoot32BitConstant(0,1,&blurRadius,0);
cmdList->SetGraphicsRoot32BitConstant(0,(UINT)weights.size(),weights.data(),1);

HLSL代码

cbuffer cbSetting : register(b0)
{
    int gBlurRadius;
    //11种模糊值
    float w0;
    float w1;
    float w2;
    float w3;
    float w4;
    float w5;
    float w6;
    float w7;
    float w8;
    float w9;
    float w10;
    
};

与根描述符一i杨,根常量无需涉及描述符堆

根签名复杂示例

着色器

Texture2D gDiffuseMap : register(t0);

cbuffer cbPerObject :  register(b0)
{
    float4x4 gWorld;
    float4x4 gTexTransform;
};

cbuffer cbPass : register(b1)
{
  float4x4 gView;
  float4x4 gInvView;
    float4x4 gProj;
    float4x4 gInvProj;
    //....
};

cbuffer cbMaterial : register(b2)
{
    float4 gDiffuseAlbedo;
    float3 gFresnelR0;
    float gRoughness;
    float4x4 gMatTransform;
};

根签名

CD3DX12_DESCRIPTOR_RANGE texTable;
texTable.Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV,1,0);
CD3DX12_ROOT_PARAMETER slotRootParameter[4];

slotRootParameter[0].InitAsDescriptorTable(1, texTable, D3D12_SHADER_VISIBILITY_PIXEL);
slotRootParameter[1].InitAsConstantBufferView(0);//寄存器b0
slotRootParameter[2].InitAsConstantBufferView(1);//寄存器b1
slotRootParameter[3].InitAsConstantBufferView(2);//寄存器b2


CD3DX12_ROOT_SIGNATURE_DESC rootSigDesc(2, slotRootParameter, 0, nullptr,
		D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);

陆地与波浪演示程序

栅格坐标

构建一个m*n个顶点组成的栅格，意味着具有(m-1)*(n-1)个四边形，即2倍的三角形

如果宽度为w,深度为d，那么x和y轴方向上的间距分别为dx=w/(n-1)和dz=d/(m-1)

那么第i行，第j列的最坐标为Vij=[-0.5w+j*dx, 0.0, 0.5d-i*dz]

uint32 vertexCount = m*n;
uint32 faceCount   = (m-1)*(n-1)*2;

float halfWidth = 0.5f*width;
float halfDepth = 0.5f*depth;

float dx = width / (n-1);
float dz = depth / (m-1);

float du = 1.0f / (n-1);
float dv = 1.0f / (m-1);

meshData.Vertices.resize(vertexCount);
for(uint32 i = 0; i < m; ++i)
{
	float z = halfDepth - i*dz;
	for(uint32 j = 0; j < n; ++j)
	{
		float x = -halfWidth + j*dx;

		meshData.Vertices[i*n+j].Position = XMFLOAT3(x, 0.0f, z);
		meshData.Vertices[i*n+j].Normal   = XMFLOAT3(0.0f, 1.0f, 0.0f);
		meshData.Vertices[i*n+j].TangentU = XMFLOAT3(1.0f, 0.0f, 0.0f);

		meshData.Vertices[i*n+j].TexC.x = j*du;
		meshData.Vertices[i*n+j].TexC.y = i*dv;
	}
}

栅格索引

三角形ABC的索引(i*n+j, i*n+j+1, (i+1)*n+j)

三角形CBD的索引((i+1)*n+j, i*n+j+1, (i+1)*n+j+1)

meshData.Indices32.resize(faceCount*3); // 3 indices per face


	uint32 k = 0;
	for(uint32 i = 0; i < m-1; ++i)
	{
		for(uint32 j = 0; j < n-1; ++j)
		{
			meshData.Indices32[k]   = i*n+j;
			meshData.Indices32[k+1] = i*n+j+1;
			meshData.Indices32[k+2] = (i+1)*n+j;

			meshData.Indices32[k+3] = (i+1)*n+j;
			meshData.Indices32[k+4] = i*n+j+1;
			meshData.Indices32[k+5] = (i+1)*n+j+1;

			k += 6; // next quad
		}
	}

构建山体

void LandAndWavesApp::BuildWavesGeometryBuffers()
{
	std::vector<std::uint16_t> indices(3 * mWaves->TriangleCount()); // 3 indices per face
	assert(mWaves->VertexCount() < 0x0000ffff);

	// Iterate over each quad.
	int m = mWaves->RowCount();
	int n = mWaves->ColumnCount();
	int k = 0;
	for(int i = 0; i < m - 1; ++i)
	{
		for(int j = 0; j < n - 1; ++j)
		{
			indices[k] = i*n + j;
			indices[k + 1] = i*n + j + 1;
			indices[k + 2] = (i + 1)*n + j;

			indices[k + 3] = (i + 1)*n + j;
			indices[k + 4] = i*n + j + 1;
			indices[k + 5] = (i + 1)*n + j + 1;

			k += 6; // next quad
		}
	}

	UINT vbByteSize = mWaves->VertexCount()*sizeof(Vertex);
	UINT ibByteSize = (UINT)indices.size()*sizeof(std::uint16_t);

	auto geo = std::make_unique<MeshGeometry>();
	geo->Name = "waterGeo";

	// Set dynamically.
	geo->VertexBufferCPU = nullptr;
	geo->VertexBufferGPU = nullptr;

	ThrowIfFailed(D3DCreateBlob(ibByteSize, &geo->IndexBufferCPU));
	CopyMemory(geo->IndexBufferCPU->GetBufferPointer(), indices.data(), ibByteSize);

	geo->IndexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), indices.data(), ibByteSize, geo->IndexBufferUploader);

	geo->VertexByteStride = sizeof(Vertex);
	geo->VertexBufferByteSize = vbByteSize;
	geo->IndexFormat = DXGI_FORMAT_R16_UINT;
	geo->IndexBufferByteSize = ibByteSize;

	SubmeshGeometry submesh;
	submesh.IndexCount = (UINT)indices.size();
	submesh.StartIndexLocation = 0;
	submesh.BaseVertexLocation = 0;

	geo->DrawArgs["grid"] = submesh;

	mGeometries["waterGeo"] = std::move(geo);
}

动态顶点缓冲区

动态顶点缓冲区即有可以频繁修改其中顶点数据的资源

如我们可以得到随着时间流走根性三角形的顶点高度，将此数据创建为动态顶点缓冲区

另外比如执行复杂的物理模拟和碰撞检测的粒子系统也需要用到

完整代码

waves

#pragma once
#ifndef WAVES_H
#define WAVES_H

#include <vector>
#include <DirectXMath.h>


class Waves
{
public:

	Waves(int m, int n, float dx, float dt, float speed, float damping);
	Waves(const Waves& rhs) = delete;
	Waves& operator=(const Waves& rhs) = delete;
	~Waves();

	int RowCount()const;
	int ColumnCount()const;
	int VertexCount()const;
	int TriangleCount()const;
	float Width()const;
	float Depth()const;

	// 第i个点的坐标
	const DirectX::XMFLOAT3& Position(int i)const { return mCurrSolution[i]; }

	// 第i个点的法线
	const DirectX::XMFLOAT3& Normal(int i)const { return mNormals[i]; }

	// 第i个点的切线
	const DirectX::XMFLOAT3& TangentX(int i)const { return mTangentX[i]; }

	void Update(float dt);
	void Disturb(int i, int j, float magnitude);


private:
	int mNumRows = 0;//行数
	int mNumCols = 0;//列数

	int mVertexCount = 0;
	int mTriangleCount = 0;

	//预先计算仿真常数。
	float mK1 = 0.0f;
	float mK2 = 0.0f;
	float mK3 = 0.0f;

	float mTimeStep = 0.0f;//时间步长
	float mSpatialStep = 0.0f;//空间步长


	std::vector<DirectX::XMFLOAT3> mPrevSolution;//上一个解决方案
	std::vector<DirectX::XMFLOAT3> mCurrSolution;//当前解决方案
	std::vector<DirectX::XMFLOAT3> mNormals;
	std::vector<DirectX::XMFLOAT3> mTangentX;
};


#endif

#include "Waves.h"
#include <DirectXMath.h>
#include <ppl.h>


using namespace DirectX;


Waves::Waves(int m, int n, float dx, float dt, float speed, float damping)
{
	mNumRows = m;
	mNumCols = n;

	mVertexCount = m * n;
	mTriangleCount = (m - 1)*(n - 1) * 2;

	mTimeStep = dt;
	mSpatialStep = dx;


	float d = damping * dt + 2.0f;
	float e = (speed*speed)*(dt*dt) / (dx*dx);

	mK1 = (damping*dt - 2.0f) / d;
	mK2 = (4.0f - 8.0f*e) / d;
	mK3 = (2.0f*e) / d;

	mPrevSolution.resize(m*n);
	mCurrSolution.resize(m*n);
	mNormals.resize(m*n);
	mTangentX.resize(m*n);


	float halfWidth = (n - 1)*dx*0.5f;
	float halfDepth = (m - 1)*dx*0.5f;
	for (int i = 0; i < m; ++i)
	{
		float z = halfDepth - i * dx;
		for (int j = 0; j < n; ++j)
		{
			float x = -halfWidth + j * dx;

			mPrevSolution[i*n + j] = XMFLOAT3(x, 0.0f, z);
			mCurrSolution[i*n + j] = XMFLOAT3(x, 0.0f, z);
			mNormals[i*n + j] = XMFLOAT3(0.0f, 1.0f, 0.0f);
			mTangentX[i*n + j] = XMFLOAT3(1.0f, 0.0f, 0.0f);
		}
	}
}

Waves::~Waves()
{

}

int Waves::RowCount() const
{
return mNumRows;
}

int Waves::ColumnCount() const
{
return mNumCols;
}

int Waves::VertexCount() const
{
return mVertexCount;
}

int Waves::TriangleCount() const
{
return mTriangleCount;
}

float Waves::Width() const
{
return mNumRows*mSpatialStep;
}

float Waves::Depth() const
{
	return mNumCols*mSpatialStep;
}

void Waves::Update(float dt)
{
	static float t =0;

	if (t>=mTimeStep)
	{
		concurrency::parallel_for(1, mNumRows - 1, [this](int i)
		{
	//此更新后，我们将丢弃旧的旧版本缓冲区，因此请使用新的更新覆盖该缓冲区。
	//注意我们如何就地执行此操作（读/写同一元素）
	//因为我们不再需要prev_ij，并且赋值最后发生。
	//注意j索引x和i索引z：h（x_j，z_i，t_k）
	//此外，我们的+ z轴会“向下”； 这只是为了与行索引下降保持一致。
			for (int j = 1; j < mNumCols - 1; ++j)
			{
				mPrevSolution[i*mNumCols + j].y =
					mK1 * mPrevSolution[i*mNumCols + j].y +
					mK2 * mCurrSolution[i*mNumCols + j].y +
					mK3 * (mCurrSolution[(i + 1)*mNumCols + j].y +
						mCurrSolution[(i - 1)*mNumCols + j].y +
						mCurrSolution[i*mNumCols + j + 1].y +
						mCurrSolution[i*mNumCols + j - 1].y);
			}
			
		});
		//我们只是用新数据覆盖了先前的缓冲区，所以此数据需要成为当前的解决方案和旧的
		//当前解决方案成为新的先前解决方案。
		std::swap(mPrevSolution, mCurrSolution);

		t = 0.0f;



		//计算法线
		concurrency::parallel_for(1, mNumRows - 1, [this](int i)
			//for(int i = 1; i < mNumRows - 1; ++i)
		{
			for (int j = 1; j < mNumCols - 1; ++j)
			{
				float l = mCurrSolution[i*mNumCols + j - 1].y;
				float r = mCurrSolution[i*mNumCols + j + 1].y;
				float t = mCurrSolution[(i - 1)*mNumCols + j].y;
				float b = mCurrSolution[(i + 1)*mNumCols + j].y;
				mNormals[i*mNumCols + j].x = -r + l;
				mNormals[i*mNumCols + j].y = 2.0f*mSpatialStep;
				mNormals[i*mNumCols + j].z = b - t;

				XMVECTOR n = XMVector3Normalize(XMLoadFloat3(&mNormals[i*mNumCols + j]));
				XMStoreFloat3(&mNormals[i*mNumCols + j], n);

				mTangentX[i*mNumCols + j] = XMFLOAT3(2.0f*mSpatialStep, r - l, 0.0f);
				XMVECTOR T = XMVector3Normalize(XMLoadFloat3(&mTangentX[i*mNumCols + j]));
				XMStoreFloat3(&mTangentX[i*mNumCols + j], T);
			}
		});

	}
}

void Waves::Disturb(int i, int j, float magnitude)
{
	assert(i > 1 && i < mNumRows - 2);
	assert(j > 1 && j < mNumCols - 2);

	float halfMag = 0.5f*magnitude;

	// 绕顶第i个顶点高度及其相邻点。
	mCurrSolution[i*mNumCols + j].y += magnitude;
	mCurrSolution[i*mNumCols + j + 1].y += halfMag;
	mCurrSolution[i*mNumCols + j - 1].y += halfMag;
	mCurrSolution[(i + 1)*mNumCols + j].y += halfMag;
	mCurrSolution[(i - 1)*mNumCols + j].y += halfMag;
}

LandAndWaves

//***************************************************************************************
// LandAndWavesApp.cpp by Frank Luna (C) 2015 All Rights Reserved.
//
// Hold down '1' key to view scene in wireframe mode.
//***************************************************************************************

#include "../../Common/d3dApp.h"
#include "../../Common/MathHelper.h"
#include "../../Common/UploadBuffer.h"
#include "../../Common/GeometryGenerator.h"
#include "FrameResource.h"
#include "Waves.h"

using Microsoft::WRL::ComPtr;
using namespace DirectX;
using namespace DirectX::PackedVector;

const int gNumFrameResources = 3;

// Lightweight structure stores parameters to draw a shape.  This will
// vary from app-to-app.
struct RenderItem
{
	RenderItem() = default;

	// World matrix of the shape that describes the object's local space
	// relative to the world space, which defines the position, orientation,
	// and scale of the object in the world.
	XMFLOAT4X4 World = MathHelper::Identity4x4();

	// Dirty flag indicating the object data has changed and we need to update the constant buffer.
	// Because we have an object cbuffer for each FrameResource, we have to apply the
	// update to each FrameResource.  Thus, when we modify obect data we should set 
	// NumFramesDirty = gNumFrameResources so that each frame resource gets the update.
	int NumFramesDirty = gNumFrameResources;

	// Index into GPU constant buffer corresponding to the ObjectCB for this render item.
	UINT ObjCBIndex = -1;

	MeshGeometry* Geo = nullptr;

	// Primitive topology.
	D3D12_PRIMITIVE_TOPOLOGY PrimitiveType = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST;

	// DrawIndexedInstanced parameters.
	UINT IndexCount = 0;
	UINT StartIndexLocation = 0;
	int BaseVertexLocation = 0;
};

enum class RenderLayer : int
{
	Opaque = 0,
	Count
};

class LandAndWavesApp : public D3DApp
{
public:
    LandAndWavesApp(HINSTANCE hInstance);
    LandAndWavesApp(const LandAndWavesApp& rhs) = delete;
    LandAndWavesApp& operator=(const LandAndWavesApp& rhs) = delete;
    ~LandAndWavesApp();

    virtual bool Initialize()override;

private:
    virtual void OnResize()override;
    virtual void Update(const GameTimer& gt)override;
    virtual void Draw(const GameTimer& gt)override;

    virtual void OnMouseDown(WPARAM btnState, int x, int y)override;
    virtual void OnMouseUp(WPARAM btnState, int x, int y)override;
    virtual void OnMouseMove(WPARAM btnState, int x, int y)override;

	void OnKeyboardInput(const GameTimer& gt);
	void UpdateCamera(const GameTimer& gt);
	void UpdateObjectCBs(const GameTimer& gt);
	void UpdateMainPassCB(const GameTimer& gt);
	void UpdateWaves(const GameTimer& gt);

    void BuildRootSignature();
    void BuildShadersAndInputLayout();
    void BuildLandGeometry();
    void BuildWavesGeometryBuffers();
    void BuildPSOs();
    void BuildFrameResources();
    void BuildRenderItems();
	void DrawRenderItems(ID3D12GraphicsCommandList* cmdList, const std::vector<RenderItem*>& ritems);

    float GetHillsHeight(float x, float z)const;
    XMFLOAT3 GetHillsNormal(float x, float z)const;

private:

    std::vector<std::unique_ptr<FrameResource>> mFrameResources;
    FrameResource* mCurrFrameResource = nullptr;
    int mCurrFrameResourceIndex = 0;

    UINT mCbvSrvDescriptorSize = 0;

    ComPtr<ID3D12RootSignature> mRootSignature = nullptr;

	std::unordered_map<std::string, std::unique_ptr<MeshGeometry>> mGeometries;
	std::unordered_map<std::string, ComPtr<ID3DBlob>> mShaders;
	std::unordered_map<std::string, ComPtr<ID3D12PipelineState>> mPSOs;

	std::vector<D3D12_INPUT_ELEMENT_DESC> mInputLayout;

	RenderItem* mWavesRitem = nullptr;

	// List of all the render items.
	std::vector<std::unique_ptr<RenderItem>> mAllRitems;

	// Render items divided by PSO.
	std::vector<RenderItem*> mRitemLayer[(int)RenderLayer::Count];

	std::unique_ptr<Waves> mWaves;

    PassConstants mMainPassCB;

    bool mIsWireframe = false;

	XMFLOAT3 mEyePos = { 0.0f, 0.0f, 0.0f };
	XMFLOAT4X4 mView = MathHelper::Identity4x4();
	XMFLOAT4X4 mProj = MathHelper::Identity4x4();

    float mTheta = 1.5f*XM_PI;
    float mPhi = XM_PIDIV2 - 0.1f;
    float mRadius = 50.0f;

	float mSunTheta = 1.25f*XM_PI;
	float mSunPhi = XM_PIDIV4;

    POINT mLastMousePos;
};

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE prevInstance,
    PSTR cmdLine, int showCmd)
{
    // Enable run-time memory check for debug builds.
#if defined(DEBUG) | defined(_DEBUG)
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif

    try
    {
        LandAndWavesApp theApp(hInstance);
        if(!theApp.Initialize())
            return 0;

        return theApp.Run();
    }
    catch(DxException& e)
    {
        MessageBox(nullptr, e.ToString().c_str(), L"HR Failed", MB_OK);
        return 0;
    }
}

LandAndWavesApp::LandAndWavesApp(HINSTANCE hInstance)
    : D3DApp(hInstance)
{
}

LandAndWavesApp::~LandAndWavesApp()
{
    if(md3dDevice != nullptr)
        FlushCommandQueue();
}

bool LandAndWavesApp::Initialize()
{
    if(!D3DApp::Initialize())
        return false;

    // Reset the command list to prep for initialization commands.
    ThrowIfFailed(mCommandList->Reset(mDirectCmdListAlloc.Get(), nullptr));

	mWaves = std::make_unique<Waves>(128, 128, 1.0f, 0.03f, 4.0f, 0.2f);

    BuildRootSignature();
    BuildShadersAndInputLayout();
	BuildLandGeometry();
    BuildWavesGeometryBuffers();
    BuildRenderItems();
	BuildRenderItems();
    BuildFrameResources();
	BuildPSOs();

    // Execute the initialization commands.
    ThrowIfFailed(mCommandList->Close());
    ID3D12CommandList* cmdsLists[] = { mCommandList.Get() };
    mCommandQueue->ExecuteCommandLists(_countof(cmdsLists), cmdsLists);

    // Wait until initialization is complete.
    FlushCommandQueue();

    return true;
}
 
void LandAndWavesApp::OnResize()
{
    D3DApp::OnResize();

    // The window resized, so update the aspect ratio and recompute the projection matrix.
    XMMATRIX P = XMMatrixPerspectiveFovLH(0.25f*MathHelper::Pi, AspectRatio(), 1.0f, 1000.0f);
    XMStoreFloat4x4(&mProj, P);
}

void LandAndWavesApp::Update(const GameTimer& gt)
{
	OnKeyboardInput(gt);
	UpdateCamera(gt);

	// Cycle through the circular frame resource array.
	mCurrFrameResourceIndex = (mCurrFrameResourceIndex + 1) % gNumFrameResources;
	mCurrFrameResource = mFrameResources[mCurrFrameResourceIndex].get();

	// Has the GPU finished processing the commands of the current frame resource?
	// If not, wait until the GPU has completed commands up to this fence point.
	if(mCurrFrameResource->Fence != 0 && mFence->GetCompletedValue() < mCurrFrameResource->Fence)
	{
		HANDLE eventHandle = CreateEventEx(nullptr, false, false, EVENT_ALL_ACCESS);
		ThrowIfFailed(mFence->SetEventOnCompletion(mCurrFrameResource->Fence, eventHandle));
		WaitForSingleObject(eventHandle, INFINITE);
		CloseHandle(eventHandle);
	}

	UpdateObjectCBs(gt);
	UpdateMainPassCB(gt);
	UpdateWaves(gt);
}

void LandAndWavesApp::Draw(const GameTimer& gt)
{
	auto cmdListAlloc = mCurrFrameResource->CmdListAlloc;

	// Reuse the memory associated with command recording.
	// We can only reset when the associated command lists have finished execution on the GPU.
	ThrowIfFailed(cmdListAlloc->Reset());

	// A command list can be reset after it has been added to the command queue via ExecuteCommandList.
	// Reusing the command list reuses memory.
    if(mIsWireframe)
    {
        ThrowIfFailed(mCommandList->Reset(cmdListAlloc.Get(), mPSOs["opaque_wireframe"].Get()));
    }
    else
    {
        ThrowIfFailed(mCommandList->Reset(cmdListAlloc.Get(), mPSOs["opaque"].Get()));
    }

	mCommandList->RSSetViewports(1, &mScreenViewport);
	mCommandList->RSSetScissorRects(1, &mScissorRect);

	// Indicate a state transition on the resource usage.
	mCommandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(CurrentBackBuffer(),
		D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET));

	// Clear the back buffer and depth buffer.
	mCommandList->ClearRenderTargetView(CurrentBackBufferView(), Colors::LightSteelBlue, 0, nullptr);
	mCommandList->ClearDepthStencilView(DepthStencilView(), D3D12_CLEAR_FLAG_DEPTH | D3D12_CLEAR_FLAG_STENCIL, 1.0f, 0, 0, nullptr);

	// Specify the buffers we are going to render to.
	mCommandList->OMSetRenderTargets(1, &CurrentBackBufferView(), true, &DepthStencilView());

	mCommandList->SetGraphicsRootSignature(mRootSignature.Get());

    // Bind per-pass constant buffer.  We only need to do this once per-pass.
	auto passCB = mCurrFrameResource->PassCB->Resource();
	mCommandList->SetGraphicsRootConstantBufferView(1, passCB->GetGPUVirtualAddress());

	DrawRenderItems(mCommandList.Get(), mRitemLayer[(int)RenderLayer::Opaque]);

	// Indicate a state transition on the resource usage.
	mCommandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(CurrentBackBuffer(),
		D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT));

	// Done recording commands.
	ThrowIfFailed(mCommandList->Close());

	// Add the command list to the queue for execution.
	ID3D12CommandList* cmdsLists[] = { mCommandList.Get() };
	mCommandQueue->ExecuteCommandLists(_countof(cmdsLists), cmdsLists);

	// Swap the back and front buffers
	ThrowIfFailed(mSwapChain->Present(0, 0));
	mCurrBackBuffer = (mCurrBackBuffer + 1) % SwapChainBufferCount;

	// Advance the fence value to mark commands up to this fence point.
	mCurrFrameResource->Fence = ++mCurrentFence;

	// Add an instruction to the command queue to set a new fence point. 
    // Because we are on the GPU timeline, the new fence point won't be 
    // set until the GPU finishes processing all the commands prior to this Signal().
	mCommandQueue->Signal(mFence.Get(), mCurrentFence);
}

void LandAndWavesApp::OnMouseDown(WPARAM btnState, int x, int y)
{
    mLastMousePos.x = x;
    mLastMousePos.y = y;

    SetCapture(mhMainWnd);
}

void LandAndWavesApp::OnMouseUp(WPARAM btnState, int x, int y)
{
    ReleaseCapture();
}

void LandAndWavesApp::OnMouseMove(WPARAM btnState, int x, int y)
{
    if((btnState & MK_LBUTTON) != 0)
    {
        // Make each pixel correspond to a quarter of a degree.
        float dx = XMConvertToRadians(0.25f*static_cast<float>(x - mLastMousePos.x));
        float dy = XMConvertToRadians(0.25f*static_cast<float>(y - mLastMousePos.y));

        // Update angles based on input to orbit camera around box.
        mTheta += dx;
        mPhi += dy;

        // Restrict the angle mPhi.
        mPhi = MathHelper::Clamp(mPhi, 0.1f, MathHelper::Pi - 0.1f);
    }
    else if((btnState & MK_RBUTTON) != 0)
    {
        // Make each pixel correspond to 0.2 unit in the scene.
        float dx = 0.2f*static_cast<float>(x - mLastMousePos.x);
        float dy = 0.2f*static_cast<float>(y - mLastMousePos.y);

        // Update the camera radius based on input.
        mRadius += dx - dy;

        // Restrict the radius.
        mRadius = MathHelper::Clamp(mRadius, 5.0f, 150.0f);
    }

    mLastMousePos.x = x;
    mLastMousePos.y = y;
}

void LandAndWavesApp::OnKeyboardInput(const GameTimer& gt)
{
    if(GetAsyncKeyState('1') & 0x8000)
        mIsWireframe = true;
    else
        mIsWireframe = false;
}

void LandAndWavesApp::UpdateCamera(const GameTimer& gt)
{
	// Convert Spherical to Cartesian coordinates.
	mEyePos.x = mRadius*sinf(mPhi)*cosf(mTheta);
	mEyePos.z = mRadius*sinf(mPhi)*sinf(mTheta);
	mEyePos.y = mRadius*cosf(mPhi);

	// Build the view matrix.
	XMVECTOR pos = XMVectorSet(mEyePos.x, mEyePos.y, mEyePos.z, 1.0f);
	XMVECTOR target = XMVectorZero();
	XMVECTOR up = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);

	XMMATRIX view = XMMatrixLookAtLH(pos, target, up);
	XMStoreFloat4x4(&mView, view);
}

void LandAndWavesApp::UpdateObjectCBs(const GameTimer& gt)
{
	auto currObjectCB = mCurrFrameResource->ObjectCB.get();
	for(auto& e : mAllRitems)
	{
		// Only update the cbuffer data if the constants have changed.  
		// This needs to be tracked per frame resource.
		if(e->NumFramesDirty > 0)
		{
			XMMATRIX world = XMLoadFloat4x4(&e->World);

			ObjectConstants objConstants;
			XMStoreFloat4x4(&objConstants.World, XMMatrixTranspose(world));

			currObjectCB->CopyData(e->ObjCBIndex, objConstants);

			// Next FrameResource need to be updated too.
			e->NumFramesDirty--;
		}
	}
}

void LandAndWavesApp::UpdateMainPassCB(const GameTimer& gt)
{
	XMMATRIX view = XMLoadFloat4x4(&mView);
	XMMATRIX proj = XMLoadFloat4x4(&mProj);

	XMMATRIX viewProj = XMMatrixMultiply(view, proj);
	XMMATRIX invView = XMMatrixInverse(&XMMatrixDeterminant(view), view);
	XMMATRIX invProj = XMMatrixInverse(&XMMatrixDeterminant(proj), proj);
	XMMATRIX invViewProj = XMMatrixInverse(&XMMatrixDeterminant(viewProj), viewProj);

	XMStoreFloat4x4(&mMainPassCB.View, XMMatrixTranspose(view));
	XMStoreFloat4x4(&mMainPassCB.InvView, XMMatrixTranspose(invView));
	XMStoreFloat4x4(&mMainPassCB.Proj, XMMatrixTranspose(proj));
	XMStoreFloat4x4(&mMainPassCB.InvProj, XMMatrixTranspose(invProj));
	XMStoreFloat4x4(&mMainPassCB.ViewProj, XMMatrixTranspose(viewProj));
	XMStoreFloat4x4(&mMainPassCB.InvViewProj, XMMatrixTranspose(invViewProj));
	mMainPassCB.EyePosW = mEyePos;
	mMainPassCB.RenderTargetSize = XMFLOAT2((float)mClientWidth, (float)mClientHeight);
	mMainPassCB.InvRenderTargetSize = XMFLOAT2(1.0f / mClientWidth, 1.0f / mClientHeight);
	mMainPassCB.NearZ = 1.0f;
	mMainPassCB.FarZ = 1000.0f;
	mMainPassCB.TotalTime = gt.TotalTime();
	mMainPassCB.DeltaTime = gt.DeltaTime();

	auto currPassCB = mCurrFrameResource->PassCB.get();
	currPassCB->CopyData(0, mMainPassCB);
}

void LandAndWavesApp::UpdateWaves(const GameTimer& gt)
{
	// Every quarter second, generate a random wave.
	static float t_base = 0.0f;
	if((mTimer.TotalTime() - t_base) >= 0.25f)
	{
		t_base += 0.25f;

		int i = MathHelper::Rand(4, mWaves->RowCount() - 5);
		int j = MathHelper::Rand(4, mWaves->ColumnCount() - 5);

		float r = MathHelper::RandF(0.2f, 0.5f);

		mWaves->Disturb(i, j, r);
	}

	// Update the wave simulation.
	mWaves->Update(gt.DeltaTime());

	// Update the wave vertex buffer with the new solution.
	auto currWavesVB = mCurrFrameResource->WavesVB.get();
	for(int i = 0; i < mWaves->VertexCount(); ++i)
	{
		Vertex v;

		v.Pos = mWaves->Position(i);
        v.Color = XMFLOAT4(DirectX::Colors::Blue);

		currWavesVB->CopyData(i, v);
	}

	// Set the dynamic VB of the wave renderitem to the current frame VB.
	mWavesRitem->Geo->VertexBufferGPU = currWavesVB->Resource();
}

void LandAndWavesApp::BuildRootSignature()
{
    // Root parameter can be a table, root descriptor or root constants.
    CD3DX12_ROOT_PARAMETER slotRootParameter[2];

    // Create root CBV.
    slotRootParameter[0].InitAsConstantBufferView(0);
    slotRootParameter[1].InitAsConstantBufferView(1);

    // A root signature is an array of root parameters.
	CD3DX12_ROOT_SIGNATURE_DESC rootSigDesc(2, slotRootParameter, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);

    // create a root signature with a single slot which points to a descriptor range consisting of a single constant buffer
    ComPtr<ID3DBlob> serializedRootSig = nullptr;
    ComPtr<ID3DBlob> errorBlob = nullptr;
    HRESULT hr = D3D12SerializeRootSignature(&rootSigDesc, D3D_ROOT_SIGNATURE_VERSION_1,
        serializedRootSig.GetAddressOf(), errorBlob.GetAddressOf());

    if(errorBlob != nullptr)
    {
        ::OutputDebugStringA((char*)errorBlob->GetBufferPointer());
    }
    ThrowIfFailed(hr);

    ThrowIfFailed(md3dDevice->CreateRootSignature(
		0,
        serializedRootSig->GetBufferPointer(),
        serializedRootSig->GetBufferSize(),
        IID_PPV_ARGS(mRootSignature.GetAddressOf())));
}

void LandAndWavesApp::BuildShadersAndInputLayout()
{
	mShaders["standardVS"] = d3dUtil::CompileShader(L"Shaders\\color.hlsl", nullptr, "VS", "vs_5_0");
	mShaders["opaquePS"] = d3dUtil::CompileShader(L"Shaders\\color.hlsl", nullptr, "PS", "ps_5_0");

    mInputLayout =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
        { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
    };
}

void LandAndWavesApp::BuildLandGeometry()
{
	GeometryGenerator geoGen;
	GeometryGenerator::MeshData grid = geoGen.CreateGrid(160.0f, 160.0f, 50, 50);

	//
	// Extract the vertex elements we are interested and apply the height function to
	// each vertex.  In addition, color the vertices based on their height so we have
	// sandy looking beaches, grassy low hills, and snow mountain peaks.
	//

	std::vector<Vertex> vertices(grid.Vertices.size());
	for(size_t i = 0; i < grid.Vertices.size(); ++i)
	{
		auto& p = grid.Vertices[i].Position;
		vertices[i].Pos = p;
		vertices[i].Pos.y = GetHillsHeight(p.x, p.z);

        // Color the vertex based on its height.
        if(vertices[i].Pos.y < -10.0f)
        {
            // Sandy beach color.
            vertices[i].Color = XMFLOAT4(1.0f, 0.96f, 0.62f, 1.0f);
        }
        else if(vertices[i].Pos.y < 5.0f)
        {
            // Light yellow-green.
            vertices[i].Color = XMFLOAT4(0.48f, 0.77f, 0.46f, 1.0f);
        }
        else if(vertices[i].Pos.y < 12.0f)
        {
            // Dark yellow-green.
            vertices[i].Color = XMFLOAT4(0.1f, 0.48f, 0.19f, 1.0f);
        }
        else if(vertices[i].Pos.y < 20.0f)
        {
            // Dark brown.
            vertices[i].Color = XMFLOAT4(0.45f, 0.39f, 0.34f, 1.0f);
        }
        else
        {
            // White snow.
            vertices[i].Color = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
        }
	}
    
	const UINT vbByteSize = (UINT)vertices.size() * sizeof(Vertex);

	std::vector<std::uint16_t> indices = grid.GetIndices16();
	const UINT ibByteSize = (UINT)indices.size() * sizeof(std::uint16_t);

	auto geo = std::make_unique<MeshGeometry>();
	geo->Name = "landGeo";

	ThrowIfFailed(D3DCreateBlob(vbByteSize, &geo->VertexBufferCPU));
	CopyMemory(geo->VertexBufferCPU->GetBufferPointer(), vertices.data(), vbByteSize);

	ThrowIfFailed(D3DCreateBlob(ibByteSize, &geo->IndexBufferCPU));
	CopyMemory(geo->IndexBufferCPU->GetBufferPointer(), indices.data(), ibByteSize);

	geo->VertexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), vertices.data(), vbByteSize, geo->VertexBufferUploader);

	geo->IndexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), indices.data(), ibByteSize, geo->IndexBufferUploader);

	geo->VertexByteStride = sizeof(Vertex);
	geo->VertexBufferByteSize = vbByteSize;
	geo->IndexFormat = DXGI_FORMAT_R16_UINT;
	geo->IndexBufferByteSize = ibByteSize;

	SubmeshGeometry submesh;
	submesh.IndexCount = (UINT)indices.size();
	submesh.StartIndexLocation = 0;
	submesh.BaseVertexLocation = 0;

	geo->DrawArgs["grid"] = submesh;

	mGeometries["landGeo"] = std::move(geo);
}

void LandAndWavesApp::BuildWavesGeometryBuffers()
{
	std::vector<std::uint16_t> indices(3 * mWaves->TriangleCount()); // 3 indices per face
	assert(mWaves->VertexCount() < 0x0000ffff);

	// Iterate over each quad.
	int m = mWaves->RowCount();
	int n = mWaves->ColumnCount();
	int k = 0;
	for(int i = 0; i < m - 1; ++i)
	{
		for(int j = 0; j < n - 1; ++j)
		{
			indices[k] = i*n + j;
			indices[k + 1] = i*n + j + 1;
			indices[k + 2] = (i + 1)*n + j;

			indices[k + 3] = (i + 1)*n + j;
			indices[k + 4] = i*n + j + 1;
			indices[k + 5] = (i + 1)*n + j + 1;

			k += 6; // next quad
		}
	}

	UINT vbByteSize = mWaves->VertexCount()*sizeof(Vertex);
	UINT ibByteSize = (UINT)indices.size()*sizeof(std::uint16_t);

	auto geo = std::make_unique<MeshGeometry>();
	geo->Name = "waterGeo";

	// Set dynamically.
	geo->VertexBufferCPU = nullptr;
	geo->VertexBufferGPU = nullptr;

	ThrowIfFailed(D3DCreateBlob(ibByteSize, &geo->IndexBufferCPU));
	CopyMemory(geo->IndexBufferCPU->GetBufferPointer(), indices.data(), ibByteSize);

	geo->IndexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), indices.data(), ibByteSize, geo->IndexBufferUploader);

	geo->VertexByteStride = sizeof(Vertex);
	geo->VertexBufferByteSize = vbByteSize;
	geo->IndexFormat = DXGI_FORMAT_R16_UINT;
	geo->IndexBufferByteSize = ibByteSize;

	SubmeshGeometry submesh;
	submesh.IndexCount = (UINT)indices.size();
	submesh.StartIndexLocation = 0;
	submesh.BaseVertexLocation = 0;

	geo->DrawArgs["grid"] = submesh;

	mGeometries["waterGeo"] = std::move(geo);
}

void LandAndWavesApp::BuildPSOs()
{
	D3D12_GRAPHICS_PIPELINE_STATE_DESC opaquePsoDesc;

	//
	// PSO for opaque objects.
	//
	ZeroMemory(&opaquePsoDesc, sizeof(D3D12_GRAPHICS_PIPELINE_STATE_DESC));
	opaquePsoDesc.InputLayout = { mInputLayout.data(), (UINT)mInputLayout.size() };
	opaquePsoDesc.pRootSignature = mRootSignature.Get();
	opaquePsoDesc.VS =
	{
		reinterpret_cast<BYTE*>(mShaders["standardVS"]->GetBufferPointer()),
		mShaders["standardVS"]->GetBufferSize()
	};
	opaquePsoDesc.PS =
	{
		reinterpret_cast<BYTE*>(mShaders["opaquePS"]->GetBufferPointer()),
		mShaders["opaquePS"]->GetBufferSize()
	};
	opaquePsoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT);
	opaquePsoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT);
	opaquePsoDesc.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT);
	opaquePsoDesc.SampleMask = UINT_MAX;
	opaquePsoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
	opaquePsoDesc.NumRenderTargets = 1;
	opaquePsoDesc.RTVFormats[0] = mBackBufferFormat;
	opaquePsoDesc.SampleDesc.Count = m4xMsaaState ? 4 : 1;
	opaquePsoDesc.SampleDesc.Quality = m4xMsaaState ? (m4xMsaaQuality - 1) : 0;
	opaquePsoDesc.DSVFormat = mDepthStencilFormat;
	ThrowIfFailed(md3dDevice->CreateGraphicsPipelineState(&opaquePsoDesc, IID_PPV_ARGS(&mPSOs["opaque"])));

    //
    // PSO for opaque wireframe objects.
    //

    D3D12_GRAPHICS_PIPELINE_STATE_DESC opaqueWireframePsoDesc = opaquePsoDesc;
    opaqueWireframePsoDesc.RasterizerState.FillMode = D3D12_FILL_MODE_WIREFRAME;
    ThrowIfFailed(md3dDevice->CreateGraphicsPipelineState(&opaqueWireframePsoDesc, IID_PPV_ARGS(&mPSOs["opaque_wireframe"])));
}

void LandAndWavesApp::BuildFrameResources()
{
    for(int i = 0; i < gNumFrameResources; ++i)
    {
        mFrameResources.push_back(std::make_unique<FrameResource>(md3dDevice.Get(),
            1, (UINT)mAllRitems.size(), mWaves->VertexCount()));
    }
}

void LandAndWavesApp::BuildRenderItems()
{
	auto wavesRitem = std::make_unique<RenderItem>();
	wavesRitem->World = MathHelper::Identity4x4();
	wavesRitem->ObjCBIndex = 0;
	wavesRitem->Geo = mGeometries["waterGeo"].get();
	wavesRitem->PrimitiveType = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
	wavesRitem->IndexCount = wavesRitem->Geo->DrawArgs["grid"].IndexCount;
	wavesRitem->StartIndexLocation = wavesRitem->Geo->DrawArgs["grid"].StartIndexLocation;
	wavesRitem->BaseVertexLocation = wavesRitem->Geo->DrawArgs["grid"].BaseVertexLocation;

	mWavesRitem = wavesRitem.get();

	mRitemLayer[(int)RenderLayer::Opaque].push_back(wavesRitem.get());

	auto gridRitem = std::make_unique<RenderItem>();
	gridRitem->World = MathHelper::Identity4x4();
	gridRitem->ObjCBIndex = 1;
	gridRitem->Geo = mGeometries["landGeo"].get();
	gridRitem->PrimitiveType = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
	gridRitem->IndexCount = gridRitem->Geo->DrawArgs["grid"].IndexCount;
	gridRitem->StartIndexLocation = gridRitem->Geo->DrawArgs["grid"].StartIndexLocation;
	gridRitem->BaseVertexLocation = gridRitem->Geo->DrawArgs["grid"].BaseVertexLocation;

	mRitemLayer[(int)RenderLayer::Opaque].push_back(gridRitem.get());

	mAllRitems.push_back(std::move(wavesRitem));
	mAllRitems.push_back(std::move(gridRitem));
}

void LandAndWavesApp::DrawRenderItems(ID3D12GraphicsCommandList* cmdList, const std::vector<RenderItem*>& ritems)
{
	UINT objCBByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(ObjectConstants));

	auto objectCB = mCurrFrameResource->ObjectCB->Resource();

	// For each render item...
	for(size_t i = 0; i < ritems.size(); ++i)
	{
		auto ri = ritems[i];

		cmdList->IASetVertexBuffers(0, 1, &ri->Geo->VertexBufferView());
		cmdList->IASetIndexBuffer(&ri->Geo->IndexBufferView());
		cmdList->IASetPrimitiveTopology(ri->PrimitiveType);

        D3D12_GPU_VIRTUAL_ADDRESS objCBAddress = objectCB->GetGPUVirtualAddress();
        objCBAddress += ri->ObjCBIndex*objCBByteSize;

		cmdList->SetGraphicsRootConstantBufferView(0, objCBAddress);

		cmdList->DrawIndexedInstanced(ri->IndexCount, 1, ri->StartIndexLocation, ri->BaseVertexLocation, 0);
	}
}

float LandAndWavesApp::GetHillsHeight(float x, float z)const
{
    return 0.3f*(z*sinf(0.1f*x) + x*cosf(0.1f*z));
}

XMFLOAT3 LandAndWavesApp::GetHillsNormal(float x, float z)const
{
    // n = (-df/dx, 1, -df/dz)
    XMFLOAT3 n(
        -0.03f*z*cosf(0.1f*x) - 0.3f*cosf(0.1f*z),
        1.0f,
        -0.3f*sinf(0.1f*x) + 0.03f*x*sinf(0.1f*z));

    XMVECTOR unitNormal = XMVector3Normalize(XMLoadFloat3(&n));
    XMStoreFloat3(&n, unitNormal);

    return n;
}

初探UE4反射系统

发表于 2020-07-08 更新于 2021-08-02 分类于 engine Changyan：

本文字数： 19k 阅读时长 ≈ 18 分钟

参考文献

《InsideUE4》UObject（四）类型系统代码生成》

创建项目 AdvanceFunc

创建2个Actor类，HelloWolrd,ByeWorld

ByeWorld的GENERATED_BODY替换成GENERATED_UCLASS_BODY

GENERATED_BODY/GENERATED_UCLASS_BODY

1	#define GENERATED_BODY(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_GENERATED_BODY);

1	#define GENERATED_BODY_LEGACY(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_GENERATED_BODY_LEGACY);

CURRENT_FILE_ID

定义在 *.generated.h的底部,如

1 2	#undef CURRENT_FILE_ID #define CURRENT_FILE_ID AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h

__LINE__

改标准宏指向了该宏使用时候的的函数。加了一个__LINE__宏的目的是为了支持在同一个文件内声明多个类，比如在MyClass.h里接着再声明UMyClass2，就可以支持生成不同的宏名称

对比2个版本的，在generated.h中发现在UCLASS版本的52行多出

1	NO_API AByeWorld(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()) : Super(ObjectInitializer) { }; \

所以UCLASS版本自动申明带FObjectInitializer 参数的构造函数

.generated.h

先看HelloWorld.generated.h的全貌

#include "UObject/ObjectMacros.h"
#include "UObject/ScriptMacros.h"

PRAGMA_DISABLE_DEPRECATION_WARNINGS
#ifdef ADVANCEFUNC_HelloWorld_generated_h
#error "HelloWorld.generated.h already included, missing '#pragma once' in HelloWorld.h"
#endif
#define ADVANCEFUNC_HelloWorld_generated_h

#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_SPARSE_DATA
#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_RPC_WRAPPERS
#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_RPC_WRAPPERS_NO_PURE_DECLS
#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_INCLASS_NO_PURE_DECLS \
private: \
	static void StaticRegisterNativesAHelloWorld(); \
	friend struct Z_Construct_UClass_AHelloWorld_Statics; \
public: \
	DECLARE_CLASS(AHelloWorld, AActor, COMPILED_IN_FLAGS(0 | CLASS_Config), CASTCLASS_None, TEXT("/Script/AdvanceFunc"), NO_API) \
	DECLARE_SERIALIZER(AHelloWorld)


#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_INCLASS \
private: \
	static void StaticRegisterNativesAHelloWorld(); \
	friend struct Z_Construct_UClass_AHelloWorld_Statics; \
public: \
	DECLARE_CLASS(AHelloWorld, AActor, COMPILED_IN_FLAGS(0 | CLASS_Config), CASTCLASS_None, TEXT("/Script/AdvanceFunc"), NO_API) \
	DECLARE_SERIALIZER(AHelloWorld)


#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_STANDARD_CONSTRUCTORS \
	/** Standard constructor, called after all reflected properties have been initialized */ \
	NO_API AHelloWorld(const FObjectInitializer& ObjectInitializer); \
	DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(AHelloWorld) \
	DECLARE_VTABLE_PTR_HELPER_CTOR(NO_API, AHelloWorld); \
DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(AHelloWorld); \
private: \
	/** Private move- and copy-constructors, should never be used */ \
	NO_API AHelloWorld(AHelloWorld&&); \
	NO_API AHelloWorld(const AHelloWorld&); \
public:


#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_ENHANCED_CONSTRUCTORS \
private: \
	/** Private move- and copy-constructors, should never be used */ \
	NO_API AHelloWorld(AHelloWorld&&); \
	NO_API AHelloWorld(const AHelloWorld&); \
public: \
	DECLARE_VTABLE_PTR_HELPER_CTOR(NO_API, AHelloWorld); \
DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(AHelloWorld); \
	DEFINE_DEFAULT_CONSTRUCTOR_CALL(AHelloWorld)


#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_PRIVATE_PROPERTY_OFFSET
#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_9_PROLOG
 //GENERATED_UCLASS_BODY定义
#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_GENERATED_BODY_LEGACY \
PRAGMA_DISABLE_DEPRECATION_WARNINGS \
public: \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_PRIVATE_PROPERTY_OFFSET \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_SPARSE_DATA \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_RPC_WRAPPERS \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_INCLASS \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_STANDARD_CONSTRUCTORS \
public: \
PRAGMA_ENABLE_DEPRECATION_WARNINGS

//GENERATED_BODY定义
#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_GENERATED_BODY \
PRAGMA_DISABLE_DEPRECATION_WARNINGS \
public: \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_PRIVATE_PROPERTY_OFFSET \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_SPARSE_DATA \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_RPC_WRAPPERS_NO_PURE_DECLS \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_INCLASS_NO_PURE_DECLS \
	AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_ENHANCED_CONSTRUCTORS \
private: \
PRAGMA_ENABLE_DEPRECATION_WARNINGS


template<> ADVANCEFUNC_API UClass* StaticClass<class AHelloWorld>();
//GENERATED_BODY定义用到的ID
#undef CURRENT_FILE_ID
#define CURRENT_FILE_ID AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h


PRAGMA_ENABLE_DEPRECATION_WARNINGS

关于GENERATED_BODY的宏定义

带PRIVATE_PROPERTY_OFFSET和PROLOG的先跳过，后面再补充

AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_INCLASS和AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_INCLASS_NO_PURE_DECLS的定义一样，如下

#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_INCLASS_NO_PURE_DECLS \
private: \
	static void StaticRegisterNativesAHelloWorld(); \
	friend struct Z_Construct_UClass_AHelloWorld_Statics; \
public: \
	DECLARE_CLASS(AHelloWorld, AActor, COMPILED_IN_FLAGS(0 | CLASS_Config), CASTCLASS_None, TEXT("/Script/AdvanceFunc"), NO_API) \
	DECLARE_SERIALIZER(AHelloWorld)


#define AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_INCLASS \
private: \
	static void StaticRegisterNativesAHelloWorld(); \
	friend struct Z_Construct_UClass_AHelloWorld_Statics; \
public: \
	DECLARE_CLASS(AHelloWorld, AActor, COMPILED_IN_FLAGS(0 | CLASS_Config), CASTCLASS_None, TEXT("/Script/AdvanceFunc"), NO_API) \
	DECLARE_SERIALIZER(AHelloWorld)

然后是AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_ENHANCED_CONSTRUCTORS和AdvanceFunc_Source_AdvanceFunc_Public_HelloWorld_h_12_STANDARD_CONSTRUCTORS,对比代码发现

后者多了NO_API AHelloWorld(const FObjectInitializer& ObjectInitializer); ,转身去看一看ByeWorld发现此版本的2个宏几乎完全一样，只是后者多了Super(ObjectInitializer) { };

这里重点要说的是不管上述宏都将C++11的拷贝构造和移动构造私有化了，目的是防止误操作

DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL

1 2	#define DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \ static void __DefaultConstructor(const FObjectInitializer& X) { new((EInternal*)X.GetObj())TClass(X); }

该声明定义了一个构造函数包装器。需要这么做的原因是，在根据名字反射创建对象的时候，需要调用该类的构造函数。可是类的构造函数并不能用函数指针指向，因此这里就用一个static函数包装一下，变成一个”平凡”的函数指针，而且所有类的签名一致，就可以在UClass里用一个函数指针里保存起来

DECLARE_CLASS

#define DECLARE_CLASS( TClass, TSuperClass, TStaticFlags, TStaticCastFlags, TPackage, TRequiredAPI  ) \
private: \
    TClass& operator=(TClass&&);   \
    TClass& operator=(const TClass&);   \
	TRequiredAPI static UClass* GetPrivateStaticClass(); \
public: \
	/** Bitwise union of #EClassFlags pertaining to this class.*/ \
	enum {StaticClassFlags=TStaticFlags}; \
	/** Typedef for the base class ({{ typedef-type }}) */ \
	typedef TSuperClass Super;\
	/** Typedef for {{ typedef-type }}. */ \
	typedef TClass ThisClass;\
	/** Returns a UClass object representing this class at runtime */ \
	inline static UClass* StaticClass() \
	{ \
		return GetPrivateStaticClass(); \
	} \
	/** Returns the package this class belongs in */ \
	inline static const TCHAR* StaticPackage() \
	{ \
		return TPackage; \
	} \
	/** Returns the static cast flags for this class */ \
	inline static EClassCastFlags StaticClassCastFlags() \
	{ \
		return TStaticCastFlags; \
	} \
	/** For internal use only; use StaticConstructObject() to create new objects. */ \
	inline void* operator new(const size_t InSize, EInternal InInternalOnly, UObject* InOuter = (UObject*)GetTransientPackage(), FName InName = NAME_None, EObjectFlags InSetFlags = RF_NoFlags) \
	{ \
		return StaticAllocateObject(StaticClass(), InOuter, InName, InSetFlags); \
	} \
	/** For internal use only; use StaticConstructObject() to create new objects. */ \
	inline void* operator new( const size_t InSize, EInternal* InMem ) \
	{ \
		return (void*)InMem; \
	}

TClass：类名
TSuperClass：基类名字
TStaticFlags：类的属性标记，这里是0，表示最默认，不带任何其他属性。读者可以查看EClassFlags枚举来查看其他定义。
TStaticCastFlags：指定了该类可以转换为哪些类，这里为0表示不能转为那些默认的类，读者可以自己查看EClassCastFlags声明来查看具体有哪些默认类转换。
TPackage：类所处于的包名，所有的对象都必须处于一个包中，而每个包都具有一个名字，可以通过该名字来查找。这里是”/Script/Hello”，指定是Script下的Hello，Script可以理解为用户自己的实现，不管是C++还是蓝图，都可以看作是引擎外的一种脚本，当然用这个名字也肯定有UE3时代UnrealScript的影子。Hello就是项目名字，该项目下定义的对象处于该包中。Package的概念涉及到后续Object的组织方式，目前可以简单理解为一个大的Object包含了其他子Object。
TRequiredAPI：就是用来Dll导入导出的标记，这里是NO_API，因为是最终exe，不需要导出。

.generated.cpp


#include "UObject/GeneratedCppIncludes.h"
#include "AdvanceFunc/Public/HelloWorld.h"
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeHelloWorld() {}//忽略
// Cross Module References
	ADVANCEFUNC_API UClass* Z_Construct_UClass_AHelloWorld_NoRegister();//构造对应的没有后续的注册过程UClass对象
	ADVANCEFUNC_API UClass* Z_Construct_UClass_AHelloWorld();//在下面L61，构造AHelloWorld对应的UClass对象
	ENGINE_API UClass* Z_Construct_UClass_AActor();
	UPackage* Z_Construct_UPackage__Script_AdvanceFunc();//构造本身的UPackage对象
// End Cross Module References
	void AHelloWorld::StaticRegisterNativesAHelloWorld()//静态注册，目前是空的
	{
	}
	UClass* Z_Construct_UClass_AHelloWorld_NoRegister()
	{
		return AHelloWorld::StaticClass();
	}
	struct Z_Construct_UClass_AHelloWorld_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_AHelloWorld_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_AActor,
		(UObject* (*)())Z_Construct_UPackage__Script_AdvanceFunc,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_AHelloWorld_Statics::Class_MetaDataParams[] = {
		{ "IncludePath", "HelloWorld.h" },
		{ "ModuleRelativePath", "Public/HelloWorld.h" },
	};
#endif
	const FCppClassTypeInfoStatic Z_Construct_UClass_AHelloWorld_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<AHelloWorld>::IsAbstract,
	};
//构造HelloWorld的UPackage
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_AHelloWorld_Statics::ClassParams = {
		&AHelloWorld::StaticClass,
		"Engine",
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		nullptr,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		0,
		0,
		0x009000A4u,
		METADATA_PARAMS(Z_Construct_UClass_AHelloWorld_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_AHelloWorld_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_AHelloWorld()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_AHelloWorld_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(AHelloWorld, 1028549712); //这个比较重要,见下文
	template<> ADVANCEFUNC_API UClass* StaticClass<AHelloWorld>()
	{
		return AHelloWorld::StaticClass();
	}
////延迟注册，注入信息，在启动的时候调用
	static FCompiledInDefer Z_CompiledInDefer_UClass_AHelloWorld(Z_Construct_UClass_AHelloWorld, &AHelloWorld::StaticClass, TEXT("/Script/AdvanceFunc"), TEXT("AHelloWorld"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(AHelloWorld);//热更新相关
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif

IMPLEMENT_CLASS

#define IMPLEMENT_CLASS(TClass, TClassCrc) \
	static TClassCompiledInDefer<TClass> AutoInitialize##TClass(TEXT(#TClass), sizeof(TClass), TClassCrc); \
	UClass* TClass::GetPrivateStaticClass() \
	{ \
		static UClass* PrivateStaticClass = NULL; \
		if (!PrivateStaticClass) \
		{ \
			/* this could be handled with templates, but we want it external to avoid code bloat */ \
			GetPrivateStaticClassBody( \
				StaticPackage(), \ //Package名字
				(TCHAR*)TEXT(#TClass) + 1 + ((StaticClassFlags & CLASS_Deprecated) ? 11 : 0), \
				PrivateStaticClass, \//输出引用
				StaticRegisterNatives##TClass, \
				sizeof(TClass), \
				alignof(TClass), \
				(EClassFlags)TClass::StaticClassFlags, \
				TClass::StaticClassCastFlags(), \
				TClass::StaticConfigName(), \
				(UClass::ClassConstructorType)InternalConstructor<TClass>, \
				(UClass::ClassVTableHelperCtorCallerType)InternalVTableHelperCtorCaller<TClass>, \
				&TClass::AddReferencedObjects, \
				&TClass::Super::StaticClass, \
				&TClass::WithinClass::StaticClass \
			); \
		} \
		return PrivateStaticClass; \
	}

目的是把该类的信息传进去给GetPrivateStaticClassBody函数，该函数真正创建UClass*

UPROPERTY,UFUNCTION

在ByeWorld里加入属性和函数

UPROPERTY(BlueprintReadWrite)
int32 number=0;

UFUNCTION(BlueprintCallable)
void BP_Callable();

UFUNCTION(BlueprintNativeEvent)
void BP_Native(float value);

UFUNCTION(BlueprintImplementableEvent)
bool BP_Implemetable(const FString& str,int32 id);

对比两文件以后，发生改变的地方如下

#define AdvanceFunc_Source_AdvanceFunc_Public_ByeWorld_h_12_RPC_WRAPPERS \
	virtual void BP_Native_Implementation(float value); \
 \
	DECLARE_FUNCTION(execBP_Native) \
	{ \
		P_GET_PROPERTY(UFloatProperty,Z_Param_value); \
		P_FINISH; \
		P_NATIVE_BEGIN; \
		P_THIS->BP_Native_Implementation(Z_Param_value); \
		P_NATIVE_END; \
	} \
 \
	DECLARE_FUNCTION(execBP_Callable) \
	{ \
		P_FINISH; \
		P_NATIVE_BEGIN; \
		P_THIS->BP_Callable(); \
		P_NATIVE_END; \
	}

#define AdvanceFunc_Source_AdvanceFunc_Public_ByeWorld_h_12_RPC_WRAPPERS_NO_PURE_DECLS \
	virtual void BP_Native_Implementation(float value); \
 \
	DECLARE_FUNCTION(execBP_Native) \
	{ \
		P_GET_PROPERTY(UFloatProperty,Z_Param_value); \
		P_FINISH; \
		P_NATIVE_BEGIN; \
		P_THIS->BP_Native_Implementation(Z_Param_value); \
		P_NATIVE_END; \
	} \
 \
	DECLARE_FUNCTION(execBP_Callable) \
	{ \
		P_FINISH; \
		P_NATIVE_BEGIN; \
		P_THIS->BP_Callable(); \
		P_NATIVE_END; \
	}

#define AdvanceFunc_Source_AdvanceFunc_Public_ByeWorld_h_12_EVENT_PARMS \
	struct ByeWorld_eventBP_Implemetable_Parms \
	{ \
		FString str; \
		int32 id; \
		bool ReturnValue; \
 \
		/** Constructor, initializes return property only **/ \
		ByeWorld_eventBP_Implemetable_Parms() \
			: ReturnValue(false) \
		{ \
		} \
	}; \
	struct ByeWorld_eventBP_Native_Parms \
	{ \
		float value; \
	};

源于蓝图虚拟机的约定，蓝图调用的函数前面会加上exec

.generated.cpp

	ADVANCEFUNC_API UFunction* Z_Construct_UFunction_AByeWorld_BP_Callable();
	ADVANCEFUNC_API UFunction* Z_Construct_UFunction_AByeWorld_BP_Implemetable();
	ADVANCEFUNC_API UFunction* Z_Construct_UFunction_AByeWorld_BP_Native();
//............
//函数名字定义
	static FName NAME_AByeWorld_BP_Implemetable = FName(TEXT("BP_Implemetable"));
	bool AByeWorld::BP_Implemetable(const FString& str, int32 id)
	{
		ByeWorld_eventBP_Implemetable_Parms Parms;
		Parms.str=str;
		Parms.id=id;
		ProcessEvent(FindFunctionChecked(NAME_AByeWorld_BP_Implemetable),&Parms);
		return !!Parms.ReturnValue;
	}
	static FName NAME_AByeWorld_BP_Native = FName(TEXT("BP_Native"));
	void AByeWorld::BP_Native(float value)
	{
		ByeWorld_eventBP_Native_Parms Parms;
		Parms.value=value;
		ProcessEvent(FindFunctionChecked(NAME_AByeWorld_BP_Native),&Parms);
	}
//注册函数名字和函数指针映射，其他2个函数类同
	void AByeWorld::StaticRegisterNativesAByeWorld()
	{
		UClass* Class = AByeWorld::StaticClass();
		static const FNameNativePtrPair Funcs[] = {
			{ "BP_Callable", &AByeWorld::execBP_Callable },
			{ "BP_Native", &AByeWorld::execBP_Native },
		};
		FNativeFunctionRegistrar::RegisterFunctions(Class, Funcs, UE_ARRAY_COUNT(Funcs));
	}
//对应函数所有反射信息，其他类同
	struct Z_Construct_UFunction_AByeWorld_BP_Callable_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AByeWorld_BP_Callable_Statics::Function_MetaDataParams[] = {
		{ "ModuleRelativePath", "Public/ByeWorld.h" },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AByeWorld_BP_Callable_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AByeWorld, nullptr, "BP_Callable", nullptr, nullptr, 0, nullptr, 0, RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AByeWorld_BP_Callable_Statics::Function_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UFunction_AByeWorld_BP_Callable_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_AByeWorld_BP_Callable()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AByeWorld_BP_Callable_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	//......................

	struct Z_Construct_UClass_AByeWorld_Statics
	{
		static UObject* (*const DependentSingletons[])();
		static const FClassFunctionLinkInfo FuncInfo[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_number_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_number;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_AByeWorld_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_AActor,
		(UObject* (*)())Z_Construct_UPackage__Script_AdvanceFunc,
	};
	const FClassFunctionLinkInfo Z_Construct_UClass_AByeWorld_Statics::FuncInfo[] = {
		{ &Z_Construct_UFunction_AByeWorld_BP_Callable, "BP_Callable" }, // 2843195228
		{ &Z_Construct_UFunction_AByeWorld_BP_Implemetable, "BP_Implemetable" }, // 3962882496
		{ &Z_Construct_UFunction_AByeWorld_BP_Native, "BP_Native" }, // 1595191378
	};
//定义UPROPERTY反射数据，（如果是TMap会有3条，本身，键，值）
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UClass_AByeWorld_Statics::NewProp_number = { "number", nullptr, (EPropertyFlags)0x0010000000000004, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(AByeWorld, number), METADATA_PARAMS(Z_Construct_UClass_AByeWorld_Statics::NewProp_number_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_AByeWorld_Statics::NewProp_number_MetaData)) };
//把所有属性加入这个数组，然后放入类的反射数据
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_AByeWorld_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_AByeWorld_Statics::NewProp_number,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_AByeWorld_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<AByeWorld>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_AByeWorld_Statics::ClassParams = {
		&AByeWorld::StaticClass,
		"Engine",
		&StaticCppClassTypeInfo,
		DependentSingletons,
		FuncInfo,
		Z_Construct_UClass_AByeWorld_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		UE_ARRAY_COUNT(FuncInfo),
		UE_ARRAY_COUNT(Z_Construct_UClass_AByeWorld_Statics::PropPointers),
		0,
		0x009000A4u,
		METADATA_PARAMS(Z_Construct_UClass_AByeWorld_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_AByeWorld_Statics::Class_MetaDataParams))
	};
//....................

总结一下

通过ConstructUFunction把对应的函数反射数据加入到反射系统

然后包括函数和属性等反射数据也加入到UCLASS一起通过ConstructUClass加入到反射系统

即通过类的反射数据可以找到类的所有成员，通过函数的反射数据找到函数的成员

C++11新特性

发表于 2020-07-07 更新于 2021-08-02 分类于 c++ Changyan：

本文字数： 7.4k 阅读时长 ≈ 7 分钟

auto

自动类型推导

1
2
3

std::vector<std::string> vec;
for(auto i = vec.begin(), i != vec.end(), ++i)
{……}

定义模板函数时，推到依赖模板函数的变量类型

template<_typename _Tx, _typename _Ty>
{
	auto v = x * y;
	std::cout<<v<<endl;
}

返回值

auto multipy(_Tx x, _Ty y)->decltype(x * y)
	return x * y;

auto func1(int a)->bool
{}

其他

1	auto a=10,b=11.0;//报错，初始化必须统一类型

int a=1;
int &b =a;
auto c=b;//c为int，去除&
auto &d=b;//d为引用
const int e=10;
auto f = e;//去除const
auto &g = e;//用&，不去除const

1
2
3

int arr[3] = {1, 2, 3};
auto brr = arr;      //brr 类型为int*
auto &crr = arr; //crr为数组，即crr=arr[3]

decltype

从变量或者表达式获取类型

int var;
const int&& fx(); 
struct A { double x; }
const A* a = new A();

decltype(var);//int
decltype(fx());//const int&&
decltype(a->x);//double
decltype((a->x));//const double&,内部括号导致语句作为表达式而不是成员访问计算。由于a声明为 const指针，因此类型是对const double的引用。

对于decltype所用的引用来说，如果变量名加上了一对括号，则得到的类型与不加括号时会有所不同。如果decltype使用的是一个不加括号的变量，则得到的结果就是该变量的类型；如果给变量加上了一层或多层括号，编译器就会把它当成是一个表达式。

C++14可以使用不带尾随返回类型的 decltype(auto) 来声明其返回类型取决于其模板参数类型的模板函数。

1
2
3

template<typename T, typename U>
decltype(auto) myFunc(T&& t, U&& u) 
        { return forward<T>(t) + forward<U>(u); };

using

命名空间

1	using namespace std;

定义别名，类似typedef

1	using itType=std::vector<std::string>::iterator;

using与typedef的差别是 using可以用于模板部分具体化，但是typedef不能

1 2	template<class T> using arr12=std::array<T,12>;

当一个派生类私有继承基类时，基类的public和protected数据成员在派生类中是private的形式，如果想让这些继承而来的数据成员作为public或者protected成员，可以用using来重新声明。using声明语句中名字的访问权限由该using声明语句之前的访问说明符决定。

class Basic{
    public:
        int a;
        int b;
};
class Bulk : private Basic{
    public:
        using Basic::a;
    protected:
        using Basic::b;

关于重写重载函数

class A1
{
public:
	void test(){cout<<"A1"; };
	void test(int a){cout<<a;};
};

class A2 :public A1
{
public:
	void test(){cout<<"A2";};
	using A1::test;//如果不加此行，A2将只保留test()部分，导致主函数内报错
};

int main()
{
	A2 a2;
	a2.test(11);//如果不用using，此行报错
	system("pause");
	return 0;
}

nullptr

nullptr比0更安全

枚举作用域

enum EnumA
{
	P1=0,
	P2=1
};
enum EnumB
{
	P1,//歧义，编译失败
	P2//歧义，编译失败
};

int main()
{
	EnumA e1=EnumA::P1;
    return 0;
}

所以我们需要设置枚举的作用域,这样才可以编译的过

enum class EnumA
{
	P1=0,
	P2=1
};
enum struct EnumB
{
	P1,
	P2
};

int main()
{
	EnumA e1=EnumA::P1;
	EnumB e2=EnumB::P2;
}

Lambda

其实lambda实现的方法是创建一个简略的类。**这个类重载了operator()**，所以表现的像个普通函数。一个lambda函数是这个类的实例。当这个类构造的时候，所有捕获的变量被传送到类中并保存为成员变量。

表达式

1	[capture](parameters)->return-type{body}

几个例子

[](int x, int y) { return x + y; } // 隐式返回类型
[](int& x) { ++x; }   // 没有return语句 -> lambda 函数的返回类型是'void'
[]() { ++global_x; }  // 没有参数,仅访问某个全局变量
[]{ ++global_x; }     // 与上一个相同,省略了()
[](int x, int y) -> int { int z = x + y; return z; }//指示了返回值int

关于[]的捕获信息

[]        //未定义变量.试图在Lambda内使用任何外部变量都是错误的.
[x, &y]   //x 按值捕获, y 按引用捕获.
[&]       //用到的任何外部变量都隐式按引用捕获
[=]       //用到的任何外部变量都隐式按值捕获
[&, x]    //x显式地按值捕获. 其它变量按引用捕获
[=, &z]   //z按引用捕获. 其它变量按值捕获
[this] //截取当前类中的this指针。如果已经使用了&或者=就默认添加此选项。

示例

A1* a1=new A1();
int a2=2;
auto lambda1=[&a1,a2](int v){a1->num=v;a2++;};//错误，a2按值传递，不能修改
auto lambda1=[&a1,a2](int v)mutable {a2++;a1->num=v+a2;;};//增加mutable后可以修改，但是对原数据无影响，输出结果a1->num : 15

explicit

显式转换，禁止单参数构造函数导致的自动转换

class plebe
{
    plebe(int);
    explicit plebe(double);
}

plebe a,b;
a=1;//隐式转换
b=0.5;//错误
b=plebe(0.5);//显式转换

default,delete

default

4类特殊函数可以用default，即默认构造函数、析构函数、拷贝构造函数以及拷贝赋值运算符

特殊情况，如果类内有指针成员，特殊函数都用default，以下情况会导致错误

class testA
{
public:
	testA() =default;
	testA(const testA& t)=default;
	~testA()=default;
	testA& operator=(const testA& t)=default;

	int num=1;
	int *p=&num;
};	

testA *a1= new testA(1);
testA *a2 =a1;
delete a1;//a2的p也被释放了
cout<<*a2->p<<endl;

delete

类内成员初始化

class se
{
    int mem1=10;//类内初始化
    double mem2{123.65};//同上
}

右值引用

左值、右值

在C++11中可以取地址的、有名字的就是左值，反之，不能取地址的、没有名字的就是右值（将亡值或纯右值）

右值、将亡值

C++98中右值是纯右值，纯右值指的是临时变量值、不跟对象关联的字面量值。
将亡值则是C++11新增的跟右值引用相关的表达式，这样表达式通常是将要被移动的对象（移为他用），比如返回右值引用T&&的函数返回值、std::move的返回值，或者转换为T&&的类型转换函数的返回值。

左值引用、右值引用

左值引用就是对一个左值进行引用的类型。右值引用就是对一个右值进行引用的类型，事实上，由于右值通常不具有名字，我们也只能通过引用的方式找到它的存在
右值引用和左值引用都是属于引用类型。无论是声明一个左值引用还是右值引用，都必须立即进行初始化
引用类型本身自己并不拥有所绑定对象的内存，只是该对象的一个别名。左值引用是具名变量值的别名，而右值引用则是不具名（匿名）变量的别名。

//int &a =2;//左值引用绑定右值，fail
int b=1;//非常量左值绑定右值，ok
const int &c=b;//常量左值引用绑定非常量左值，ok
const int &d=2;//常量左值引用绑定常量左值,ok
int && f=10;//右值引用绑定右值,ok
const int &g=f;//常量左值引用绑定右值引用,ok
//int &&h=b;//右值引用绑定非常量左值，fail
int &&h=std::move(b);//move把左值转换为右值，ok
//int &&i=h;//变量是左值，h是左值,fail

智能指针

智能指针是用对象去管理一个资源指针，同时用一个计数器计算引用当前指针对象的个数，当管理指针的对象增加或减少时，计数器也相应加1或减1，当最后一个指针管理对象销毁时，计数器为1，此时在销毁指针管理对象的同时，也对指针管理对象所管理的指针进行delete操作。

shared_ptr

std::shared_ptr包装了new操作符动态分配的内存，可以自由拷贝复制，基本上是使用最多的一个智能指针类型。

注意事项

我们尽量使用shared_ptr构造函数或者make_shared的方式创建shared_ptr，禁止使用裸指针赋值的方式，这样会shared_ptr难于管理指针的生命周期。

// 使用裸指针赋值构造，不推荐，裸指针被释放后，shared_ptr就野了，不能完全控制裸指针的生命周期，失去了智能指针价值
int *p = new int(10);
shared_ptr<int>sp = p;
delete p; // sp将成为野指针，使用sp将crash
// 将裸指针作为匿名指针传入构造函数，一般做法，让shared_ptr接管裸指针的生命周期，更安全
shared_ptr<int>sp1(new int(10));
// 使用make_shared，推荐做法，更符合工厂模式，可以连代码中的所有new，更高效；方法的参数是用来初始化模板类
shared_ptr<int>sp2 = make_shared<int>(10);

禁止使用指向shared_ptr的裸指针，也就是智能指针的指针，使用shared_ptr的指针指向一个shared_ptr时，引用计数并不会加一，操作shared_ptr的指针很容易就发生野指针异常。

shared_ptr<int>sp = make_shared<int>(10);
cout << sp.use_count() << endl; //输出1
shared_ptr<int> *sp1 = &sp;
cout << (*sp1).use_count() << endl; //输出依然是1
(*sp1).reset(); //sp成为野指针
cout << *sp << endl; //crash

weak_ptr

与std::shared_ptr最大的差别是在赋值的时候，不会引起智能指针计数增加。

class A {
public:
	shared_ptr<B> b;
};
class B {
public:
	weak_ptr<A> a;
};

int main()
{
	
	shared_ptr<A> spa = make_shared<A>();
	shared_ptr<B> spb = make_shared<B>();
	spa->b = spb; //spb强引用计数为2，弱引用计数为1
	spb->a = spa; //spa强引用计数为1，弱引用计数为2

	system("pause");
	return 0;
}

weak_ptr的一些用法

weak_ptr<T> w;  //空weak_ptr可以指向类型为T的对象
weak_ptr<T> w(shared_ptr sp);   //与sp指向相同对象的weak_ptr, T必须能转换为sp指向的类型
w = p;  //p可以是shared_ptr或者weak_ptr，赋值后w和p共享对象
w.reset();  //weak_ptr置为空
w.use_count();  //与w共享对象的shared_ptr的计数
w.expired();    //w.use_count()为0则返回true，否则返回false
w.lock();   //w.expired()为true，返回空的shared_ptr;否则返回指向w的shared_ptr

unique_ptr

unique_ptr是auto_ptr的继承者，对于同一块内存只能有一个持有者，而unique_ptr和auto_ptr唯一区别就是unique_ptr不允许赋值操作，也就是不能放在等号的右边（函数的参数和返回值例外），这一定程度避免了一些误操作导致指针所有权转移，然而，unique_str依然有提供所有权转移的方法move，调用move后，原unique_ptr就会失效

unique_ptr<int> p1=make_unique<int>(11);
cout<<*p1<<endl;//11
auto p2=move(p1);
cout<<*p1<<endl;//访问空指针，崩溃

模板和STL方面的修改

基于范围的for循环

1
2
3

double price[5]={1.1,2.2,3.3,4.4,5.5};
for(double x:prices)//也可以使用auto来申明x，编译器将自动推断
    std::cout<<x<<std::endl;

新的STL容器

C++11新增的容器：forward_list,unordered_map,unordered_multimap,unordered_set,unordered_multiset

关于unordered_map与map

两者的接口差不多，基本可以互换。

一般来说unordered_map的综合性能比map要好，因此，通常我们可以使用unorderd_map代替map。

以下情况推荐使用map：

关键字类型的hash函数设计的很差，或者==运算符的性能极差，导致hash过程太耗时；
对内存使用有严格要求, 不能接受存储hash table的额外内存开销；
元素要求按顺序存储，或者常常需要关联访问一个元素的上一个/下一个元素，或者需要遍历整个map。

新的STL方法

新增了STL方法cbegin()和cend()，这些方法也返回一个迭代器，指向容器的第一个元素和最后一个元素的后面，因此可以用于指定包含全部元素的区间；这些新方法将元素视为const。类似的，crbegin()和crend()是rbegin()和rend()的const版本

valarray升级

C++11添加了两个函数begin()和end()，都接受valarray作为参数并且返回迭代器

摒弃export

C++98增加了关键字export，C++11摒弃了这个特性但是保留了关键字export

尖括号

为了避免与运算符>>混淆，C++要求在申明嵌套模板时使用空格将尖括号分开

1	vector<list<int>> vl;//C++11开始不再强求空格

DX学习笔记（四）：绘制几何体

发表于 2020-06-30 更新于 2021-08-02 分类于 graphics Changyan：

本文字数： 44k 阅读时长 ≈ 40 分钟

用DirectX绘制几何体

流程简述

顶点与输入布局

创建顶点结构体
设置输入布局描述D3D12_INPUT_ELEMENT_DESC

顶点/索引缓冲区

创建顶点数据/索引数据
创建缓冲区/索引缓冲区

顶点着色/像素着色

编写HLSL着色器文件
编译着色器

常量缓冲区（上传堆，CPU可写，GPU可读）

填充常量缓冲区所需的描述符(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV)
构造缓冲区对象（单独的类），该类创建常量缓冲区
设置缓冲区大小为256B的整数倍
创建常量缓冲区视图
创建根签名

后续在提交命令列表的时候讲根签名和常量缓冲区绑定到流水线

流水线状态对象 PSO

创建PSO对象 D3D12_GRAPHICS_PIPELINE_STATE_DESC
设置PSO对象的各类参数，包括输入布局描述符、根签名、PS、VS、光栅器对象等
通过md3dDevice->CreateGraphicsPipelineState(&psoDesc,IID_PPV_ARGS(&mPSO))创建PSO

构建几何体

顶点/索引数据，布局描述
创建Geo类，并且设置类内参数，这些参数在填充视口描述的时候需要
创建顶点/索引缓冲区
在绘制阶段通过命令列表将顶点和索引视图绑定到流水线插槽
通过DrawIndexedInstanced绘制几何体

刷新（update）

根据鼠标信息重新构建观察矩阵（相对坐标的变换）
刷新常量缓冲区

Resize

重新构建透视投影矩阵
然后反馈到Update的常量缓冲区上

世界矩阵随移动/旋转/缩放而改变

观察矩阵随虚拟摄像机的移动/旋转/缩放而改变

投影矩阵随窗口大小调整而改变

刷新的数据通过根签名设置到着色器

顶点与输入布局

顶点结构体

struct Vertex
{
    XMFLOAT3 Pos;
    XMFLOAT4 Color;
};

struct Vertex2
{
    XMFLOAT3 Pos;
    XMFLOAT3 Normal;
    XMFLOAT2 Tex0;
    XMFLOAT2 Tex1;
}

输入布局描述

typedef struct D3D12_INPUT_LAYOUT_DESC
    {
    _Field_size_full_(NumElements)  const D3D12_INPUT_ELEMENT_DESC *pInputElementDescs;
    UINT NumElements;//数量
    } 	D3D12_INPUT_LAYOUT_DESC;

typedef struct D3D12_INPUT_ELEMENT_DESC
    {
    LPCSTR SemanticName;
    UINT SemanticIndex;
    DXGI_FORMAT Format;
    UINT InputSlot;
    UINT AlignedByteOffset;
    D3D12_INPUT_CLASSIFICATION InputSlotClass;
    UINT InstanceDataStepRate;
    } 	D3D12_INPUT_ELEMENT_DESC;

SemanticName：语义，用于将顶点结构体中的元素与顶点着色器输入签名（参数列表）中的元素映射起来
SemanticIndex：附加到语义的索引。
Format：顶点元素格式，如DXGI_FORMAT_R32_FLOAT1D32位浮点标量
InputSlot：传递元素所用的输入槽，DirectX12一共16个，索引0-15，一般用同一个输入槽即输入槽0
AlignedByteOffset：顶点结构体的首地址到某点元素起始地址的偏移量

struct Vertex2
{
    XMFLOAT3 Pos;//偏移0字节
    XMFLOAT3 Normal;//偏移12字节
    XMFLOAT2 Tex0;//偏移24字节
    XMFLOAT2 Tex1;//偏移32字节
}

InputSlotClass：一般指定为D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA，另外一种D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA用于实现实例化的高级技术
InstanceDataStepRate：一般设置0，如果采用实例化就用1

示例

D3D12_INPUT_ELEMENT_DESC desc1 =
  {
      { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
      { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
  };

D3D12_INPUT_ELEMENT_DESC desc2 =
  {
      { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
      { "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
    { "TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 24, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
      { "TEXCOORD", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 32, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
  };

顶点缓冲区

为了使GPU可以访问顶点数组，就需要把它们放置在缓冲区的GPU资源（ID2D12Resource）

顶点缓冲区：存储顶点的缓冲区
缓冲区描述:CD3D12_RESOURCE_DESC

struct CD3DX12_RESOURCE_DESC : public D3D12_RESOURCE_DESC
{
    CD3DX12_RESOURCE_DESC()
    {}
    explicit CD3DX12_RESOURCE_DESC( const D3D12_RESOURCE_DESC& o ) :
        D3D12_RESOURCE_DESC( o )
    {}
    CD3DX12_RESOURCE_DESC( 
        D3D12_RESOURCE_DIMENSION dimension,
        UINT64 alignment,
        UINT64 width,
        UINT height,
        UINT16 depthOrArraySize,
        UINT16 mipLevels,
        DXGI_FORMAT format,
        UINT sampleCount,
        UINT sampleQuality,
        D3D12_TEXTURE_LAYOUT layout,
        D3D12_RESOURCE_FLAGS flags )
        /**********/
}

此描述继承自D3D_RESOURCE_DESC，重点实现了几个比较便捷的方法如

static inline CD3DX12_RESOURCE_DESC Buffer( 
       UINT64 width,
       D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE,
       UINT64 alignment = 0 )
   {
       return CD3DX12_RESOURCE_DESC( D3D12_RESOURCE_DIMENSION_BUFFER, alignment, width, 1, 1, 1, 
           DXGI_FORMAT_UNKNOWN, 1, 0, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, flags );
   }

其他还有比如CD3DX12_RESOURCE_DESC::Tex1D,CD3DX12_RESOURCE_DESC::2D等便捷方法

然后通过ID3D12Device::CreateCommittedResource方法创建ID3D12Resource对象

示例：创建默认缓冲区函数申明

// Create the actual default buffer resource.
  ThrowIfFailed(device->CreateCommittedResource(
      &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT),
      D3D12_HEAP_FLAG_NONE,
      &CD3DX12_RESOURCE_DESC::Buffer(byteSize),
D3D12_RESOURCE_STATE_COMMON,
      nullptr,
      IID_PPV_ARGS(defaultBuffer.GetAddressOf())));

DX12中所有资源都用ID3D12Resource接口表示，DX11用各种比如ID3D11Buffers等表示

为了优化性能，静态几何体的顶点缓冲区置于默认堆中

因为CPU不能向默认堆(D3D12_HEAP_TYPE_DEFAULT)中的顶点缓冲区写入数据，所以就需要用到一个中介

上传缓冲区
为了将数据从CPU复制到GPU显存中，即将顶点数据从系统内存复制到上传缓冲区，然后再复制到真正的顶点缓冲区中
示例:创建默认缓冲区函数实现

Microsoft::WRL::ComPtr<ID3D12Resource> d3dUtil::CreateDefaultBuffer(
    ID3D12Device* device,
    ID3D12GraphicsCommandList* cmdList,
    const void* initData,
    UINT64 byteSize,
    Microsoft::WRL::ComPtr<ID3D12Resource>& uploadBuffer)
{
    ComPtr<ID3D12Resource> defaultBuffer;

    //创建实际的默认缓冲区资源
    ThrowIfFailed(device->CreateCommittedResource(
        &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT),
        D3D12_HEAP_FLAG_NONE,
        &CD3DX12_RESOURCE_DESC::Buffer(byteSize),
		D3D12_RESOURCE_STATE_COMMON,
        nullptr,
        IID_PPV_ARGS(defaultBuffer.GetAddressOf())));

    //为了将CPU端内存中的数据复制到缓冲区，我们就创建处于中介位置的上传堆
    ThrowIfFailed(device->CreateCommittedResource(
        &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD),
		D3D12_HEAP_FLAG_NONE,
        &CD3DX12_RESOURCE_DESC::Buffer(byteSize),
		D3D12_RESOURCE_STATE_GENERIC_READ,
        nullptr,
        IID_PPV_ARGS(uploadBuffer.GetAddressOf())));


    // 描述我们希望复制到默认缓冲区的数据
    D3D12_SUBRESOURCE_DATA subResourceData = {};
    subResourceData.pData = initData;
    subResourceData.RowPitch = byteSize;
    subResourceData.SlicePitch = subResourceData.RowPitch;

    //将数据复制到默认缓冲区的流程
    //UpdateSubresources辅助函数将数据从CPU复制到上传堆
    //再通过ID3D12CommandList::CopySubresourceRegion函数复制到mBuff中
	cmdList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(defaultBuffer.Get(), 
		D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_COPY_DEST));
    UpdateSubresources<1>(cmdList, defaultBuffer.Get(), uploadBuffer.Get(), 0, 0, 1, &subResourceData);
	cmdList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(defaultBuffer.Get(),
		D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_GENERIC_READ));

    // uploadBuffer必须在调用方法以后依然存在，因为命令列表的复制操作可能未执行，等调用者复制完消息以后才可以释放


    return defaultBuffer;
}

D3D12_SUBRESOURCE_DATA

typedef struct D3D12_SUBRESOURCE_DATA
    {
    const void *pData;//初始化缓冲区所用的数据指针
    LONG_PTR RowPitch;//对于缓冲区，此参数为欲复制数据的字节数
    LONG_PTR SlicePitch;//同上
    } 	D3D12_SUBRESOURCE_DATA;

示例：创建有立方体8个顶点的默认缓冲区

 std::array<Vertex, 8> vertices =
    {
        Vertex({ XMFLOAT3(-1.0f, -1.0f, -1.0f), XMFLOAT4(Colors::White) }),
		Vertex({ XMFLOAT3(-1.0f, +1.0f, -1.0f), XMFLOAT4(Colors::Black) }),
		Vertex({ XMFLOAT3(+1.0f, +1.0f, -1.0f), XMFLOAT4(Colors::Red) }),
		Vertex({ XMFLOAT3(+1.0f, -1.0f, -1.0f), XMFLOAT4(Colors::Green) }),
		Vertex({ XMFLOAT3(-1.0f, -1.0f, +1.0f), XMFLOAT4(Colors::Blue) }),
		Vertex({ XMFLOAT3(-1.0f, +1.0f, +1.0f), XMFLOAT4(Colors::Yellow) }),
		Vertex({ XMFLOAT3(+1.0f, +1.0f, +1.0f), XMFLOAT4(Colors::Cyan) }),
		Vertex({ XMFLOAT3(+1.0f, -1.0f, +1.0f), XMFLOAT4(Colors::Magenta) })
    };

const UINT vbByteSize = (UINT)vertices.size() * sizeof(Vertex);
Microsoft::WRL::ComPtr<ID3D12Resource> VertexBufferGPU = nullptr;
Microsoft::WRL::ComPtr<ID3D12Resource> VertexBufferUploader = nullptr;

mBoxGeo->VertexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), vertices.data(), vbByteSize, mBoxGeo->VertexBufferUploader);

顶点缓冲区视图:为了将顶点缓冲区绑定到渲染流水线

typedef struct D3D12_VERTEX_BUFFER_VIEW
    {
    D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
    UINT SizeInBytes;
    UINT StrideInBytes;
    }

BufferLocation：顶点缓冲区的虚拟地址，通过ID3D12Resource::GetGPUVirtualAddress方法得到此地址
SizeInBytes：顶点缓冲区大小（字节）
StrideInBytes：每个顶点元素占用的字节

然后将顶点缓冲区视图和渲染流水线上的一个输入槽绑定

//第一个参数：所用的输入槽，一般用0
//第二个参数：与输入槽绑定的缓冲区数量，即pView数组中视图的数量
//视图数组的第一个元素的地址
mCommandList->IASetVertexBuffers(0, 1, &mBoxGeo->VertexBufferView());

将顶点缓冲区置入输入槽并不会进行绘制操作，仅仅是为顶点数据送至渲染流水线做好准备

真正绘制顶点的方法

//参数1：每个实例绘制的顶点数
//参数2：实例化高级技术，目前给1
//参数3：第一个被绘制顶点的索引
//参数4：实例化技术，目前给0
mCommandList->DrawIndexedInstanced(
		mBoxGeo->DrawArgs["box"].IndexCount, 
		1, 0, 0, 0);

索引和索引缓冲区

索引缓冲区

与顶点类似，为了使GPU可以访问索引数组，需要将它们放置于GPU的缓冲区资源内,此缓冲区即索引缓冲区

同样用CreateDefaultBuffer方法创建索引缓冲区

索引缓冲区用到结构体D3D12_INDEX_BUFFER_VIEW描述

typedef struct D3D12_INDEX_BUFFER_VIEW
    {
    D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;//带创建索引缓冲区虚拟地址，用ID3D12Resource::GetGUPVirtualAddress()得到
    UINT SizeInBytes;//索引缓冲区大小
    DXGI_FORMAT Format;//必须为DXGI_FORMAT_R16_UINT类型或者DXGI_FORMAT_R32_UINT
    }

同顶点缓冲区，也需要绑定到渲染流水线，通过ID3D12GraphicsCommandList::IASetIndexBuffer方法将索引缓冲区绑定到输入装配器阶段

	std::array<std::uint16_t, 36> indices =
	{
		// front face
		0, 1, 2,
		0, 2, 3,

		// back face
		4, 6, 5,
		4, 7, 6,

		// left face
		4, 5, 1,
		4, 1, 0,

		// right face
		3, 2, 6,
		3, 6, 7,

		// top face
		1, 5, 6,
		1, 6, 2,

		// bottom face
		4, 0, 3,
		4, 3, 7
	};

const UINT ibByteSize = (UINT)indices.size() * sizeof(std::uint16_t);

Microsoft::WRL::ComPtr<ID3D12Resource> IndexBufferGPU = nullptr;
Microsoft::WRL::ComPtr<ID3D12Resource> IndexBufferUploader = nullptr;

mBoxGeo->IndexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), indices.data(), ibByteSize, mBoxGeo->IndexBufferUploader);

使用索引时，要用ID3D12GraphicsCommandList::DrawIndexedInstanced代替DrawInstanced方法

//第4个参数：读取顶点之前，要为每个索引都加上的整数值
//其他参考顶点绘制
mCommandList->DrawIndexedInstanced(
		mBoxGeo->DrawArgs["box"].IndexCount, 
		1, 0, 0, 0);

将多个顶点缓冲区和索引缓冲区合并以后会需要用到第4个参数

1
2
3

mCommandList->DrawIndexedInstanced(numOfBox, 1, 0, 0, 0);
mCommandList->DrawIndexedInstanced(numOfSph, 1, firstSphIdx, firstSphIdx, 0);
mCommandList->DrawIndexedInstanced(numOfCyl, 1, firstCylIdx, firstCylIdx, 0);

顶点着色器示例

高级着色器语言：HLSL

示例

cbuffer cbPerObject:register(b0)
{
    float4x4 gWorldViewProj;
}
void VS(float3 iPosL:POSITION,float4 iColor:COLOR,out float4 oPosH:SV_POSTION,out float4 oColor:COLOR)
{
    //把顶点变换到齐次裁剪空间
    oPosH = mul(float4(iPosL,1.0f),gWolrdViewProj);
    //将顶点颜色信息传至像素着色器
    oColor=iColor;
}

HLSL没有指针和引用，用out表示输出参数

HLSL所有函数都是lnline函数

参数POSITION和COLOR语义将元素映射到顶点着色器对应的输入参数；同理输出参数的语义将参数映射到下一个阶段（几何着色器或者像素着色器）对应的输入参数；

SV_POSTION的SV代表系统值，此数据存有齐次裁剪空间顶点信息，指定了此语义以后使GPU进行如裁剪、深度测试等处理时，实现其他属性无法介入的有关运算

任何没有系统修饰的参数，都可以根据需求以合法的语义修饰

可以把函数的参数封装成结构体，下面是另一种实现方式

struct VertexIn
{
    float3 PosL:POSTION;
    float4 Color:COLOR;
};
struct VertexOut
{
    float3 PosH:SV_POSTION;
    float4 Color:COLOR;
};
VextexOut VS(VertexIn vin)
{
    VertexOut vout;
    vout.PosH=mul(float4(vin.PosL,1.0f),gWolrdViewProj);
    vout.Color=vin.Color;
    return vout;
}

如果没有使用几何着色器，那么顶点着色器必须用SV_POSITION来输出顶点在齐次裁剪空间的位置

如果使用了，可以把得到齐次裁剪空间位置的工作交给它来处理

顶点着色器/几何着色器无法完成透视除法，此阶段只能完成投影矩阵运算，透视除法由后续硬件执行

布局描述符与签名匹配问题

ID3D12Device::CreateGraphicsPipelineState函数时，需要指定布局描述符和顶点着色器,这就涉及到参数匹配问题

不匹配

struct Vertex
{
    XMFLOAT3 Pos;
    XMFLOAT4 Color;
    //XMFLOAT3 Normal;//缺少此行输入
}

 D3D12_INPUT_ELEMENT_DESC[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
        { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
      { "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 24, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
    };

struct VertexIn
{
    float3 PosL:POSTION;
    float4 Color:COLOR;
    float3 Normal:NORMAL;
};
struct VertexOut
{
    float3 PosH:SV_POSTION;
    float4 Color:COLOR;
};

VertexOut VS(VertexIn vin){...};

匹配

struct Vertex
{
    XMFLOAT3 Pos;
    XMFLOAT4 Color;
    XMFLOAT3 Normal;
}

 D3D12_INPUT_ELEMENT_DESC[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
        { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
      { "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 24, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
    };

struct VertexIn
{
    float3 PosL:POSTION;
    float4 Color:COLOR;
    //float3 Normal:NORMAL;//输入有多余的参数可以匹配
};
struct VertexOut
{
    float3 PosH:SV_POSTION;
    float4 Color:COLOR;
};

VertexOut VS(VertexIn vin){...};

匹配

struct Vertex
{
    XMFLOAT3 Pos;
    XMFLOAT4 Color;
    XMFLOAT3 Normal;
}

 D3D12_INPUT_ELEMENT_DESC[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
        { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
      { "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 24, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
    };

struct VertexIn
{
    float3 PosL:POSTION;
    float4 Color:COLOR;
    int3  Normal:NORMAL;//Direct3D会对数据类型重新解释，但会报警告
};
struct VertexOut
{
    float3 PosH:SV_POSTION;
    float4 Color:COLOR;
};

VertexOut VS(VertexIn vin){...};

像素着色器示例

光栅化阶段先对顶点着色器进行插值计算，然后把数据传递至像素着色器作为输出

像素着色器针对每一个像素片段而运行的函数，但是部分像素片段不会传入或者留存在后台缓冲区，会在深度测试等情况被丢弃掉；即像素是最终写入后台缓冲区的数据，像素片段是候选像素

示例

cbuffer cbPerObject:register(b0)
{
    float4x4 gWorldViewProj;
}
void VS(float3 iPosL:POSITION,float4 iColor:COLOR,out float4 oPosH:SV_POSTION,out float4 oColor:COLOR)
{
    //把顶点变换到齐次裁剪空间
    oPosH = mul(float4(iPosL,1.0f),gWolrdViewProj);
    //将顶点颜色信息传至像素着色器
    oColor=iColor;
}

float4 PS(float4 posH:SV_POSITION,float4 color:COLOR):SV_TARGET
{
    return color;
}

参数列表后的SV_TARGET表示该返回值的类型樱岛与渲染目标格式相匹配(render target format )1

同样可以利用输入输出结构体来重写上述代码

struct VertexIn
{
    float3 PosL:POSTION;
    float4 Color:COLOR;
  
};
struct VertexOut
{
    float3 PosH:SV_POSTION;
    float4 Color:COLOR;
};
VextexOut VS(VertexIn vin)
{
    VertexOut vout;
    vout.PosH=mul(float4(vin.PosL,1.0f),gWolrdViewProj);
    vout.Color=vin.Color;
    return vout;
}
float4 PS(VertexOut pin):VS_TARGET
{
    return pin.Color;
}

常量缓冲区

创建常量缓冲区

常量缓冲区也是一种GPU资源ID3D12Resource

cbuffer cbPerObject:register(b0)
{
    float4x4 gWorldViewProj;
}

此代码中的cbuffer对象（常量缓冲区）的名称就是cbPerObject，存储一个4x4矩阵gWorldViewProj

此矩阵表示把一个点从局部空间变换到齐次裁剪空间所用到的由世界、视图和投影3种变换组合而成的矩阵

与顶点和索引缓冲区不同，从常量缓冲区由CPU每帧更新顶一次

常量缓冲区创建到上传堆而非默认堆，使得我们从CPU端更新常量

常量缓冲区的硬件有特别要求，大小必须为256B的整数倍

示例

struct ObjectConstants
{
    XMFLOAT4X4 WorldViewProj = MathHelper::Identity4x4();
};

 UINT mElementByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(T));//换算使得缓冲区大小保持在256B的倍数

Microsoft::WRL::ComPtr<ID3D12Resource> mUploadBuffer;
ThrowIfFailed(device->CreateCommittedResource(
            &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD),
            D3D12_HEAP_FLAG_NONE,
            &CD3DX12_RESOURCE_DESC::Buffer(mElementByteSize*elementCount),
			D3D12_RESOURCE_STATE_GENERIC_READ,
            nullptr,
            IID_PPV_ARGS(&mUploadBuffer)));

mUploadCBuffer存储了一个ObjectConstants类型的常量缓冲区数组

绘制物体时，只要将常量缓冲区视图CBV绑定到那个存有物体相应常量缓冲区的子区域即可

着色器模型5.1

struct ObjectConstants
{
    float4x4 gWorldViewProj;
    uint matIndex;
};
ConstantBuffer<ObjectConstants> gObjConstants : register(b0);

常量缓冲区的数据元素被定义在一个单独的结构体中，随后用这个结构来创建一个常量缓冲区，然后就可以在着色器里访问常量缓冲区中的各个字段

1	uint index = gObjConstants.matIndex;

着色器模型定义了HLSL的编写规范，确定了其内置函数、着色器属性等一切语言元素

更新常量缓冲区

常量缓冲区是用D3D12_HEAP_TYPE_UPLOAD类型创建的，所以可以用CPU为常量缓冲区更新数据

Microsoft::WRL::ComPtr<ID3D12Resource> mUploadBuffer;
BYTE* mMappedData = nullptr;
//参数1：预映射的子资源，对于缓冲区来说设置为0
//参数2：指向D3D12_RANGE结构体的可选项，描述了映射范围，如果是空就对整个资源映射
//参数3：双重指针返回待映射资源书的目标内存块
ThrowIfFailed(mUploadBuffer->Map(0, nullptr, reinterpret_cast<void**>(&mMappedData)));

1	memcpy(mMappedData,&data,dataSizeInBytes);//用此函数将数据从系统内存复制到常量缓冲区

等更新完成，然后在释放映射内存之前对其进行Unmap(取消映射)操作

1
2
3

if(mUploadBuffer != nullptr)
    mUploadBuffer->Unmap(0,nullptr);
mMappedData = nullptr;

Unmap的第一个参数是子资源索引，第二个是指向D3D12_RANGE结构体的指针，描述取消映射的内存范围，如空则整个资源映射。

上传缓冲区辅助函数

UploadBuffer类

template<typename T>
class UploadBuffer
{
public:
    UploadBuffer(ID3D12Device* device, UINT elementCount, bool isConstantBuffer) : 
        mIsConstantBuffer(isConstantBuffer)
    {
        mElementByteSize = sizeof(T);

        //常量缓冲区的大小为256B的整数倍
        //长度者两种规格来查看常量数据
        //UINT64 SizeInBytes;//256的整数倍
        //UINT OffsetInBytes;//256的整数倍
        if(isConstantBuffer)
            mElementByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(T));

        ThrowIfFailed(device->CreateCommittedResource(
            &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD),
            D3D12_HEAP_FLAG_NONE,
            &CD3DX12_RESOURCE_DESC::Buffer(mElementByteSize*elementCount),
			D3D12_RESOURCE_STATE_GENERIC_READ,
            nullptr,
            IID_PPV_ARGS(&mUploadBuffer)));

        ThrowIfFailed(mUploadBuffer->Map(0, nullptr, reinterpret_cast<void**>(&mMappedData)));

        //只要还会需改当前的资源，我们就无需取消映射
        // 但是在资源被GPU使用期间，我们千万不可向该资源进行写操作（所以需要借助同步技术）
    }

    UploadBuffer(const UploadBuffer& rhs) = delete;
    UploadBuffer& operator=(const UploadBuffer& rhs) = delete;
    ~UploadBuffer()
    {
        if(mUploadBuffer != nullptr)
            mUploadBuffer->Unmap(0, nullptr);

        mMappedData = nullptr;
    }

    ID3D12Resource* Resource()const
    {
        return mUploadBuffer.Get();
    }

    void CopyData(int elementIndex, const T& data)
    {
        memcpy(&mMappedData[elementIndex*mElementByteSize], &data, sizeof(T));
    }

private:
    Microsoft::WRL::ComPtr<ID3D12Resource> mUploadBuffer;
    BYTE* mMappedData = nullptr;

    UINT mElementByteSize = 0;
    bool mIsConstantBuffer = false;
};

世界矩阵随移动/旋转/缩放而改变

观察矩阵随虚拟摄像机的移动/旋转/缩放而改变

投影矩阵随窗口大小调整而改变

OnMouseMove

void BoxApp::OnMouseMove(WPARAM btnState, int x, int y)
{
    if((btnState & MK_LBUTTON) != 0)
    {
        // 根据鼠标的移动距离计算旋转角度，令每个像素按此角度的1/4旋转
        float dx = XMConvertToRadians(0.25f*static_cast<float>(x - mLastMousePos.x));
        float dy = XMConvertToRadians(0.25f*static_cast<float>(y - mLastMousePos.y));

        // 根据鼠标输入来更新摄像机绕立方体旋转的角度
        mTheta += dx;
        mPhi += dy;

        // 限制角度mPhi的范围
        mPhi = MathHelper::Clamp(mPhi, 0.1f, MathHelper::Pi - 0.1f);
    }
    else if((btnState & MK_RBUTTON) != 0)
    {
        // 使场景中的每个像素按鼠标移动距离的0.005倍进行缩放
        float dx = 0.005f*static_cast<float>(x - mLastMousePos.x);
        float dy = 0.005f*static_cast<float>(y - mLastMousePos.y);

        // 根据鼠标的输入更新摄像机的可视范围半径
        mRadius += dx - dy;

        // 限制可视半径范围
        mRadius = MathHelper::Clamp(mRadius, 3.0f, 15.0f);
    }

    mLastMousePos.x = x;
    mLastMousePos.y = y;
}

Update

void BoxApp::Update(const GameTimer& gt)
{
    // 将球坐标（球面坐标）转换为笛卡尔坐标系
    float x = mRadius*sinf(mPhi)*cosf(mTheta);
    float z = mRadius*sinf(mPhi)*sinf(mTheta);
    float y = mRadius*cosf(mPhi);

    // 构建观察矩阵
    XMVECTOR pos = XMVectorSet(x, y, z, 1.0f);
    XMVECTOR target = XMVectorZero();
    XMVECTOR up = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);

    XMMATRIX view = XMMatrixLookAtLH(pos, target, up);
    XMStoreFloat4x4(&mView, view);

    XMMATRIX world = XMLoadFloat4x4(&mWorld);
    XMMATRIX proj = XMLoadFloat4x4(&mProj);
    XMMATRIX worldViewProj = world*view*proj;

	// 用最新的 worldViewProj 矩阵来更新常量缓冲区
	ObjectConstants objConstants;
    XMStoreFloat4x4(&objConstants.WorldViewProj, XMMatrixTranspose(worldViewProj));
    mObjectCB->CopyData(0, objConstants);
}

常量缓冲区描述符

常量缓冲区描述符都存放在以D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV类型的描述符堆里，这个堆混合存储了常量缓冲区、着色器资源和无序访问描述符

D3D12_DESCRIPTOR_HEAP_DESC cbvHeapDesc;
   cbvHeapDesc.NumDescriptors = 1;
   cbvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
   cbvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
cbvHeapDesc.NodeMask = 0;
   ThrowIfFailed(md3dDevice->CreateDescriptorHeap(&cbvHeapDesc,
       IID_PPV_ARGS(&mCbvHeap)));

在创建着色器程序访问的描述符时，需要把Flags指定为DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE

然后通过如下代码创建常量缓冲区

void BoxApp::BuildConstantBuffers()
{
    //此常量缓冲区存储了绘制n个物体所需的常量数据
	std::unique_ptr<UploadBuffer<ObjectConstants>> mObjectCB = std::make_unique<UploadBuffer<ObjectConstants>>(md3dDevice.Get(), 1, true);

	UINT objCBByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(ObjectConstants));
	//缓冲区的起始地址	
	D3D12_GPU_VIRTUAL_ADDRESS cbAddress = mObjectCB->Resource()->GetGPUVirtualAddress();
    //偏移到常量缓冲区中绘制第i个物体所需的常量数据
    int boxCBufIndex = 0;
	cbAddress += boxCBufIndex*objCBByteSize;

	D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc;
	cbvDesc.BufferLocation = cbAddress;
	cbvDesc.SizeInBytes = d3dUtil::CalcConstantBufferByteSize(sizeof(ObjectConstants));

	md3dDevice->CreateConstantBufferView(
		&cbvDesc,
		mCbvHeap->GetCPUDescriptorHandleForHeapStart());
}

根签名和描述符表

根签名

//将纹理资源绑定到纹理寄存器槽0
Texture2D gDiffuseMap : register(t0);
//把下列采样器资源一次绑定到采样器槽0-5
SamplerState gsamPointWrap : register(s0);
SamplerState gsamPointClamp : register(s1);
//将常量缓冲区资源绑定到常量缓冲区寄存器槽0
cbuffer cbPerObject : register(b0)
{
    float4x4 gWorld;
    float4x4 gTexTransform;
}
//绘制每种材质所需的各种不同的常量数据
cbuffer cbMaterial : register(b2)
{
    float4 gDiffuseAlbedo;
    float3 gFresnelR0;
    float gRoughness;
    float4x4 gMatTransform;
}

register(*#)中的*表示寄存器传递的资源类型。

t:着色器资源视图；

s:采样器

u:无序访问视图

b:常量缓冲区视图

在执行绘制命令之前，那些应用程序将绑定到渲染流水线上的资源，它们会被映射到着色器的对应输入寄存器。

根签名一定要与使用它的着色器相兼容，在创建流水线状态对象时会对此进行验证

不同的绘制调用可能会用到一组不同的着色器程序，意味着要用到不同的根签名

在Direct3D中，根签名由ID3D12RootSignature接口表示，并用一组描述绘制调用过程中着色器所需资源的根参数定义而成。

根参数可以是根常量、根描述符或者描述符表

如果把着色器程序看成是一个大函数，那顶点数据和常量数据就是从CPU传入着色器函数的参数，而根签名就好比这些参数的函数签名。所以根签名其实就是将着色器需要用到的数据绑定到对应的寄存器槽上，供着色器访问。

示例

oid BoxApp::BuildRootSignature()
{
	// Shader programs typically require resources as input (constant buffers,
	// textures, samplers).  The root signature defines the resources the shader
	// programs expect.  If we think of the shader programs as a function, and
	// the input resources as function parameters, then the root signature can be
	// thought of as defining the function signature.  

	// 根参数可以是根常量、根描述符或者描述符表
	CD3DX12_ROOT_PARAMETER slotRootParameter[1];

	// 创建一个只存有一个CBV的描述符表
	CD3DX12_DESCRIPTOR_RANGE cbvTable;
	cbvTable.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0);//1：表中的描述符数量，0：将此段描述符区域绑定至此基准着色器寄存器
	slotRootParameter[0].InitAsDescriptorTable(1, &cbvTable);//1：描述符区域的数量；table:指向描述符区域数组的指针

	// 根签名由一组根参数构成
	CD3DX12_ROOT_SIGNATURE_DESC rootSigDesc(1, slotRootParameter, 0, nullptr, 
		D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);

	//创建仅含一个槽位的根签名
	ComPtr<ID3DBlob> serializedRootSig = nullptr;
	ComPtr<ID3DBlob> errorBlob = nullptr;
	HRESULT hr = D3D12SerializeRootSignature(&rootSigDesc, D3D_ROOT_SIGNATURE_VERSION_1,
		serializedRootSig.GetAddressOf(), errorBlob.GetAddressOf());

	if(errorBlob != nullptr)
	{
		::OutputDebugStringA((char*)errorBlob->GetBufferPointer());
	}
	ThrowIfFailed(hr);

	ThrowIfFailed(md3dDevice->CreateRootSignature(
		0,
		serializedRootSig->GetBufferPointer(),
		serializedRootSig->GetBufferSize(),
		IID_PPV_ARGS(&mRootSignature)));
}

// Root parameter can be a table, root descriptor or root constants.
	CD3DX12_ROOT_PARAMETER slotRootParameter[1];
cbvTable.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV,//描述符表的类型
              1, //表中描述符的数量
              0);//将这段描述符区域绑定至此基础着色器寄存器
	slotRootParameter[0].InitAsDescriptorTable(1,//描述符区域的数量
                                               &cbvTable);//指向描述符区域数组的指针

上述代码创建了一个根参数，目的是将含有一个CBV的描述符表绑定到常量缓冲区寄存器0，即HLSL代码中的register(b0)

根签名至定义了应用程序要绑定到渲染流水线的资源，没有真正的执行任何资源绑定操作

只有通过命令列表设置根签名，才可以用ID3D12GraphicsCommandList::SetGraphicsRootDescriptorTable 方法令描述符表与渲染流水线绑定

1
2

mCommandList->SetGraphicsRootDescriptorTable(0, //将根参数按此索引进行设置
mCbvHeap->GetGPUDescriptorHandleForHeapStart());//此参数指定的是将要想着色器绑定的描述符表中的第一个描述符位于描述符堆中的句柄

下列代码先将根签名和CBV堆设置到命令列表上，并随后通过设置描述符表来指定我们希望绑定到渲染流水线的资源

mCommandList->SetGraphicsRootSignature(mRootSignature.Get());

ID3D12DescriptorHeap* descriptorHeaps[] = { mCbvHeap.Get() };
	mCommandList->SetDescriptorHeaps(_countof(descriptorHeaps), descriptorHeaps);
//偏移到此次绘制调用所需的CBV处
CD3DX12_GPU_DESCRIPTOR_HANDLE cbv(mCbvHeap->GetGPUDescriptorHandleForHeapStart());
cbv.Offset(cbvIndex,mCbvSrvUavDescriptorSize);

mCommandList->SetGraphicsRootDescriptorTable(0,cbv);

编译着色器

着色器程序必须先被编译为一种可移植的字节码，接下来图形驱动程序将获取这些字节码，并将其重新便以为针对当前系统GPU所优化的本地指令[ATI1]

可以用如下函数在运行期间对着色器进行编译

HRESULT D3DCompileFromFile(
	LPCWSTR pFileName,//希望编译的以.hlsl作为扩展名的源代码文件
    const D3D_SHADER_MACRO *pDefines,//本书中用nullptr
    ID3DInclude *pInclude,//同上
    LPOCSTR pEntrypoint,//着色器入口点函数，一个.hlsl文件可能存有多个着色器程序
    LPCSTR pTarget,//指定所用着色器类型和版本的字符串，本书用的是5.0和5.1
    UINT Flags1,//一般用2种：D3DCOMPLIE_DEBUG/D3DCOMPILE_SKIP_OPTIMIZATIOIN，详见SDK
    UINT Flags2,//本书不用
    ID3DBlob **ppCode,//返回一个数据结构指针，存储着编译好的着色器对象字节码
    ID3DBlob **ppErrorMsgs//返回报错信息               
);

ID3DBlob

一段普通的内存块，有2个接口方法

LPVOID GetBufferPointer:返回对象中数据的void*类型的指针，使用之前需要转换为适当类型
SIZE_T GetBufferSize：返回缓冲区字节大小

运行时编译着色器函数

ComPtr<ID3DBlob>  CompileShader(
	const std::wstring& fileName, 
	const D3D_SHADER_MACRO* defines, 
	const std::string& enteryPoint, 
	const std::string& target)
{
	//若处于调试模式，则使用调试标志
	UINT compileFlags = 0;
#if defined(DEBUG) || defined(_DEBUG)
	//用调试模式来编译着色器 | 指示编译器跳过优化阶段
	compileFlags = D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;
#endif // defined(DEBUG) || defined(_DEBUG)

	HRESULT hr = S_OK;

	ComPtr<ID3DBlob> byteCode = nullptr;
	ComPtr<ID3DBlob> errors;
	hr = D3DCompileFromFile(fileName.c_str(), //hlsl源文件名
		defines,	//高级选项，指定为空指针
		D3D_COMPILE_STANDARD_FILE_INCLUDE,	//高级选项，可以指定为空指针
		enteryPoint.c_str(),	//着色器的入口点函数名
		target.c_str(),		//指定所用着色器类型和版本的字符串
		compileFlags,	//指示对着色器断代码应当如何编译的标志
		0,	//高级选项
		&byteCode,	//编译好的字节码
		&errors);	//错误信息

	if (errors != nullptr)
	{
		OutputDebugStringA((char*)errors->GetBufferPointer());
	}
	ThrowIfFailed(hr);

	return byteCode;
}

离线编译

离线编译的原因

对于复杂的着色器，编译耗时太长，因此借助离线编译即可缩短应用程序的加载时间
以便在早于运行时的构建处理期间提早发现编译错误
对于Windows9应用商店的应用而言，必须采取离线编译这种方式

一般用.cso为已编译的着色器对象的扩展名

使用DirectX自带的FXC命令行编译工具编译

如用CMD输入代码编译

1	C:\Program Files (x86)\Windows Kits\10\bin\x86>fxc.exe C:\Users\Administrator\Desktop\color.hlsl /T vs_5_0 /Fo "color.cso" /E "VS"

成功输出color.cso文件

compilation object save succeeded; see C:\Program Files (x86)\Windows Kits\10\bin\x86\color.cso

常用的编译参数

参数	描述
/Od	禁用优化（利于调试）
/Zi	开启调试信息
/T “string”	着色器模型版本,如输入`vs_5_0`
/E “string”	着色器入口，如案例中的`VS`,`PS`
/Fo “string”	经过编译的着色器对象字节码
/Fc “string”	输出一个着色器汇编语言清单（调试、查阅细节）

其他清单可以参考微软SDK文档

光栅器状态

光栅器状态只接受配置，非可编程，由结构体D3D12_RASTERIZER_DESC表示

typedef struct D3D12_RASTERIZER_DESC
    {
    D3D12_FILL_MODE FillMode;//默认：D3D12_FILL_MODE_SOLID
    D3D12_CULL_MODE CullMode;//默认: D3D12_CULL_MODE_BACK
    BOOL FrontCounterClockwise;//默认:false
    INT DepthBias;
    FLOAT DepthBiasClamp;
    FLOAT SlopeScaledDepthBias;
    BOOL DepthClipEnable;
    BOOL MultisampleEnable;
    BOOL AntialiasedLineEnable;
    UINT ForcedSampleCount;
    D3D12_CONSERVATIVE_RASTERIZATION_MODE ConservativeRaster;
    } 	D3D12_RASTERIZER_DESC;

FillMode:默认是实体渲染，如果用D3D12_FILL_MODE_WIREFRAME则是线框渲染

CullMode：默认剔除背面，D3D12_CULL_MODE_NONE不剔除，D3D12_CULL_MODE_FRONT剔除正面

FrontCounterClockwise：默认false，根据观察视角，将定点顺序为顺时针方向的三角形看作正面；如true则相反

示例

1
2
3

CD3DX12_RASTERIZER_DESC rsDesc(D3D12_DEFAULT);
reDesc.FillMode = D3D12_FILL_MODE_WIREFRAME;
reDesc.CullMode = D3D12_CULL_MODE_NONE;

CD3DX12_RASTERIZER_DESC是扩展自D3DX12_RASTERIZER_DESC的结构，添加了一些辅助构造函数的工具类，如接受CD3DX12_DEFAULT参数的构造函数。

CD3DX12_DEFAULT是一个哑类型(dummy),将需要被初始化的成员重载为默认值

1 2	struct CD3DX12_DEFAULT {}; extern const DECLSPEC_SELECTANY CD3DX12_DEFAULT D3D12_DEFAULT;

流水线状态对象

ID3D12PipelineState表示流水线状态对象(PSO)

结构体

typedef struct D3D12_GRAPHICS_PIPELINE_STATE_DESC
    {
    ID3D12RootSignature *pRootSignature;//指向一个于此PSO绑定的根签名，该根签名必须与PSO指定的着色器兼容
    D3D12_SHADER_BYTECODE VS;//待绑定的顶点着色器，用结构体 D3D12_SHADER_BYTECODE表示
    D3D12_SHADER_BYTECODE PS;//待绑定的像素着色器
    D3D12_SHADER_BYTECODE DS;//域着色器
    D3D12_SHADER_BYTECODE HS;//外壳着色器
    D3D12_SHADER_BYTECODE GS;//几何着色器
    D3D12_STREAM_OUTPUT_DESC StreamOutput;//流输出高级技术
    D3D12_BLEND_DESC BlendState;//混合，默认指定CD3DX12_BLEND_DESC(D3D12_DEFAULT)
    UINT SampleMask;//禁止的采样，默认0xffffffff都进行采样
    D3D12_RASTERIZER_DESC RasterizerState;//指定用来配置光栅器的光栅化状态
    D3D12_DEPTH_STENCIL_DESC DepthStencilState;//用于配置深度/模板测试的深度/模板状态，默认用D3D12_DEPTH_STENCIL_DESC(D3D12_DEFAULT)
    D3D12_INPUT_LAYOUT_DESC InputLayout;//输入布局描述，有两个成员，D3D12_INPUT_ELEMENT_DESC数组和一个表示元素个数的无符号整数
    D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue;
    D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType;//图元的拓扑类型，D3D12_PRIMITIVE_TOPOLOGY_TYPE
    UINT NumRenderTargets;//同时所用的渲染目标数量
    DXGI_FORMAT RTVFormats[ 8 ];//渲染目标格式
    DXGI_FORMAT DSVFormat;//深度/模板缓冲的格式
    DXGI_SAMPLE_DESC SampleDesc;//多重采样对每个像素采样的数量和质量级别
    UINT NodeMask;
    D3D12_CACHED_PIPELINE_STATE CachedPSO;
    D3D12_PIPELINE_STATE_FLAGS Flags;
    } 	D3D12_GRAPHICS_PIPELINE_STATE_DESC;

示例

D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc;
    ZeroMemory(&psoDesc, sizeof(D3D12_GRAPHICS_PIPELINE_STATE_DESC));
    psoDesc.InputLayout = { mInputLayout.data(), (UINT)mInputLayout.size() };
    psoDesc.pRootSignature = mRootSignature.Get();
    psoDesc.VS = 
	{ 
		reinterpret_cast<BYTE*>(mvsByteCode->GetBufferPointer()), 
		mvsByteCode->GetBufferSize() 
	};
    psoDesc.PS = 
	{ 
		reinterpret_cast<BYTE*>(mpsByteCode->GetBufferPointer()), 
		mpsByteCode->GetBufferSize() 
	};
    psoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT);
    psoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT);
    psoDesc.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT);
    psoDesc.SampleMask = UINT_MAX;
    psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
    psoDesc.NumRenderTargets = 1;
    psoDesc.RTVFormats[0] = mBackBufferFormat;
    psoDesc.SampleDesc.Count = m4xMsaaState ? 4 : 1;
    psoDesc.SampleDesc.Quality = m4xMsaaState ? (m4xMsaaQuality - 1) : 0;
    psoDesc.DSVFormat = mDepthStencilFormat;
    ThrowIfFailed(md3dDevice->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&mPSO)));

PSO的验证和创建过于耗时，所以一般在初始化期间就生成PSO

视口和裁剪矩形等属性独立于PSO

用不同的PSO绘制不同的物体

mCommandList->Reset(mDirectCmdListAlloc.Get(),mPSO1.Get());

mCommandList->Reset(mDirectCmdListAlloc.Get(),mPSO2.Get());

mCommandList->Reset(mDirectCmdListAlloc.Get(),mPSO3.Get());

几何图形辅助结构体

此结构体定义了MeshGeometry中存储的单个几何体

struct SubmeshGeometry
{
	UINT IndexCount = 0;
	UINT StartIndexLocation = 0;
	INT BaseVertexLocation = 0;

    // 通过此子网格来定义当前结构体中所存几何体的包围盒 bounding box ，后续章节会讲述
	DirectX::BoundingBox Bounds;
};

struct MeshGeometry
{
	// 几何体网格集的名称
	std::string Name;

	// 系统内存中的副本，由于顶点/索引可以是泛型格式，所以用Blob类型
	Microsoft::WRL::ComPtr<ID3DBlob> VertexBufferCPU = nullptr;
	Microsoft::WRL::ComPtr<ID3DBlob> IndexBufferCPU  = nullptr;

	Microsoft::WRL::ComPtr<ID3D12Resource> VertexBufferGPU = nullptr;
	Microsoft::WRL::ComPtr<ID3D12Resource> IndexBufferGPU = nullptr;

	Microsoft::WRL::ComPtr<ID3D12Resource> VertexBufferUploader = nullptr;
	Microsoft::WRL::ComPtr<ID3D12Resource> IndexBufferUploader = nullptr;

    // 缓冲区数据
	UINT VertexByteStride = 0;
	UINT VertexBufferByteSize = 0;
	DXGI_FORMAT IndexFormat = DXGI_FORMAT_R16_UINT;
	UINT IndexBufferByteSize = 0;

	// 一个结构体能够存储一组顶点/索引缓冲区中的多个几何体
    //用下列容器来定义子网格几何体，就能单独绘制其中的子网格
	std::unordered_map<std::string, SubmeshGeometry> DrawArgs;

	D3D12_VERTEX_BUFFER_VIEW VertexBufferView()const
	{
		D3D12_VERTEX_BUFFER_VIEW vbv;
		vbv.BufferLocation = VertexBufferGPU->GetGPUVirtualAddress();
		vbv.StrideInBytes = VertexByteStride;
		vbv.SizeInBytes = VertexBufferByteSize;

		return vbv;
	}

	D3D12_INDEX_BUFFER_VIEW IndexBufferView()const
	{
		D3D12_INDEX_BUFFER_VIEW ibv;
		ibv.BufferLocation = IndexBufferGPU->GetGPUVirtualAddress();
		ibv.Format = IndexFormat;
		ibv.SizeInBytes = IndexBufferByteSize;

		return ibv;
	}

	// 等数据上传GPU后，我们就能释放内存了
	void DisposeUploaders()
	{
		VertexBufferUploader = nullptr;
		IndexBufferUploader = nullptr;
	}
};

绘制Box

#include <Windows.h>
#include "../Common/d3dUtil.h"
#include "DXApp.h"
#include "../Common/UploadBuffer.h"
#include "../Common/MathHelper.h"


using namespace DirectX;
using namespace DirectX::PackedVector;
using Microsoft::WRL::ComPtr;

#define  _DEBUG 1
struct Vertex
{
	XMFLOAT3 Pos;
	XMFLOAT4 Color;
};

struct ObjectConstants
{
	XMFLOAT4X4 WorldViewProj=MathHelper::Identity4x4();
};

class MyBox:public DXApp
{
public:
	MyBox(HINSTANCE instance);
	MyBox(const MyBox& rhs)=delete;
	MyBox& operator=(const MyBox& rhs)=delete;
	~MyBox();
	virtual bool Initialize()override;

	

	
private:
	virtual void OnMouseDown(WPARAM btnState, int x, int y)override;
	virtual void OnMouseUp(WPARAM btnState, int x, int y)override;
	virtual void OnMouseMove(WPARAM btnState, int x, int y)override;
	
	void BuildDescriptorHeaps();//常量缓冲区描述符堆
	void BuildConstantBuffers();
	void BuildRootSignature();
	void BuildShadersAndInputLayout();
	void BuildBoxGeometry();
	void BuildPSO();

	virtual void Update(const GameTimer& gt)override;
	virtual void Draw(const GameTimer& gt)override;
	virtual void OnResize()override;

	ComPtr<ID3D12DescriptorHeap> mCbvHeap = nullptr;
	ComPtr<ID3D12RootSignature> mRootSignature = nullptr;
	std::unique_ptr<UploadBuffer<ObjectConstants>> mObjectCB = nullptr;
	//封装的几何体结构体的指针
	std::unique_ptr<MeshGeometry> mBoxGeo = nullptr;

	//编译材质参数
	ComPtr<ID3DBlob> mvsByteCode = nullptr;
	ComPtr<ID3DBlob> mpsByteCode = nullptr;
	//输入布局描述
	std::vector<D3D12_INPUT_ELEMENT_DESC> mInputLayout;
	
	ComPtr<ID3D12PipelineState> mPSO = nullptr;
	

	XMFLOAT4X4 mWorld = MathHelper::Identity4x4();
	XMFLOAT4X4 mView = MathHelper::Identity4x4();
	XMFLOAT4X4 mProj = MathHelper::Identity4x4();

	float mTheta = 1.5f*XM_PI;
	float mPhi = XM_PIDIV2;
	float mRadius = 5.0f;
	POINT mLastMousePos;
};

MyBox::MyBox(HINSTANCE instance):DXApp(instance)
{
	
}



MyBox::~MyBox()
{

}

void MyBox::Update(const GameTimer& gt)
{
	// 将球坐标（球面坐标）转换为笛卡尔坐标系
	float x = mRadius * sinf(mPhi)*cosf(mTheta);
	float z = mRadius * sinf(mPhi)*sinf(mTheta);
	float y = mRadius * cosf(mPhi);

	// 构建观察矩阵
	XMVECTOR pos = XMVectorSet(x, y, z, 1.0f);
	XMVECTOR target = XMVectorZero();
	XMVECTOR up = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);

	XMMATRIX view = XMMatrixLookAtLH(pos, target, up);
	XMStoreFloat4x4(&mView, view);//观察矩阵

	XMMATRIX world = XMLoadFloat4x4(&mWorld);
	XMMATRIX proj = XMLoadFloat4x4(&mProj);
	XMMATRIX worldViewProj = world * view*proj;

	// 用最新的 worldViewProj 矩阵来更新常量缓冲区
	ObjectConstants objConstants;
	XMStoreFloat4x4(&objConstants.WorldViewProj, XMMatrixTranspose(worldViewProj));
	mObjectCB->CopyData(0, objConstants);

}

void MyBox::Draw(const GameTimer& gt)
{
	ThrowIfFailed(mDirectCmdListAlloc->Reset());
	ThrowIfFailed(mCommandList->Reset(mDirectCmdListAlloc.Get(), mPSO.Get()));

	mCommandList->RSSetViewports(1,&mScreenViewport);
	mCommandList->RSSetScissorRects(1,&mScissorRect);
	//指示资源使用情况的状态转换。
	mCommandList->ResourceBarrier(1,&CD3DX12_RESOURCE_BARRIER::Transition(CurrentBackBuffer(),D3D12_RESOURCE_STATE_PRESENT,D3D12_RESOURCE_STATE_RENDER_TARGET));
	//清理后台缓冲区和深度缓冲区
	mCommandList->ClearRenderTargetView(CurrentBackBufferView(),Colors::LightSteelBlue,0,nullptr);
	mCommandList->ClearDepthStencilView(DepthStencilView(),D3D12_CLEAR_FLAG_DEPTH | D3D12_CLEAR_FLAG_STENCIL,1.0f,0,0,nullptr);
	//指定要渲染的缓冲区
	mCommandList->OMSetRenderTargets(1 , &CurrentBackBufferView(),true, &DepthStencilView());

	//指定cbv描述符堆成员为一个
	ID3D12DescriptorHeap* descriptorHeaps[]={mCbvHeap.Get()};
	mCommandList->SetDescriptorHeaps(_countof(descriptorHeaps),descriptorHeaps);
	//设置根签名
	mCommandList->SetGraphicsRootSignature(mRootSignature.Get());

	//顶点缓冲区视图和渲染流水线上的一个输入槽绑定
	mCommandList->IASetVertexBuffers(0,1,&mBoxGeo->VertexBufferView());
	mCommandList->IASetIndexBuffer(&mBoxGeo->IndexBufferView());
	mCommandList->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);//这里是DX11版本，没有12版本

	//描述符表与渲染流水线绑定
	mCommandList->SetGraphicsRootDescriptorTable(0,mCbvHeap->GetGPUDescriptorHandleForHeapStart());

	mCommandList->DrawIndexedInstanced(mBoxGeo->DrawArgs["box"].IndexCount,1,0,0,0);

	mCommandList->ResourceBarrier(1,&CD3DX12_RESOURCE_BARRIER::Transition(CurrentBackBuffer(), D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT));


	ThrowIfFailed(mCommandList->Close());

	//提交命令列表，交换前后台缓冲区
	ID3D12CommandList* cmdLists[]={mCommandList.Get()};
	mCommandQueue->ExecuteCommandLists(_countof(cmdLists),cmdLists);


	ThrowIfFailed(mSwapChain->Present(0,0));
	mCurrBackBuffer=(mCurrBackBuffer+1)%SwapChainBufferCount;

	FlushCommandQueue();

}

void MyBox::OnResize()
{
	DXApp::OnResize();

	// The window resized, so update the aspect ratio and recompute the projection matrix.
	XMMATRIX P = XMMatrixPerspectiveFovLH(0.25f*MathHelper::Pi, AspectRatio(), 1.0f, 1000.0f);
	XMStoreFloat4x4(&mProj, P);
}

void MyBox::OnMouseDown(WPARAM btnState, int x, int y)
{
	mLastMousePos.x = x;
	mLastMousePos.y = y;

	SetCapture(mhMainWnd);
}

void MyBox::OnMouseUp(WPARAM btnState, int x, int y)
{
	ReleaseCapture();
}

void MyBox::OnMouseMove(WPARAM btnState, int x, int y)
{
	if ((btnState & MK_LBUTTON) != 0)
	{
		//  根据鼠标的移动距离计算旋转角度，令每个像素按此角度的1/4旋转
		float dx = XMConvertToRadians(0.25f*static_cast<float>(x - mLastMousePos.x));
		float dy = XMConvertToRadians(0.25f*static_cast<float>(y - mLastMousePos.y));

		// 根据鼠标输入来更新摄像机绕立方体旋转的角度
		mTheta -= dx;
		mPhi -= dy;

		//限制角度mPhi的范围
		mPhi = MathHelper::Clamp(mPhi, 0.1f, MathHelper::Pi - 0.1f);
	}
	else if ((btnState & MK_RBUTTON) != 0)
	{
		// 使场景中的每个像素按鼠标移动距离的0.005倍进行缩放
		float dx = 0.005f*static_cast<float>(x - mLastMousePos.x);
		float dy = 0.005f*static_cast<float>(y - mLastMousePos.y);

		// 根据鼠标的输入更新摄像机的可视范围半径
		mRadius += dx - dy;

		// 限制可视半径范围
		mRadius = MathHelper::Clamp(mRadius, 3.0f, 15.0f);
	}

	mLastMousePos.x = x;
	mLastMousePos.y = y;
}

void MyBox::BuildDescriptorHeaps()
{
	D3D12_DESCRIPTOR_HEAP_DESC cbvHeapDesc;
	cbvHeapDesc.Flags=D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;//创建着色器程序访问的描述符时需要指定visible
	cbvHeapDesc.NodeMask=0;
	cbvHeapDesc.NumDescriptors=1;
	cbvHeapDesc.Type=D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
	ThrowIfFailed(md3dDevice->CreateDescriptorHeap(&cbvHeapDesc,IID_PPV_ARGS(&mCbvHeap)));

}

void MyBox::BuildConstantBuffers()
{ 
	//此常量缓冲区存储了绘制n个物体所需的常量数据
	mObjectCB=std::make_unique<UploadBuffer<ObjectConstants>>(md3dDevice.Get(),1,true);

	UINT objCBByteSize=d3dUtil::CalcConstantBufferByteSize(sizeof(ObjectConstants));
	//缓冲区的起始地址	
	D3D12_GPU_VIRTUAL_ADDRESS cbAddress=mObjectCB->Resource()->GetGPUVirtualAddress();

	int boxCBufIndex=0;
	cbAddress += boxCBufIndex*objCBByteSize;

	D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc;
	cbvDesc.BufferLocation = cbAddress;
	cbvDesc.SizeInBytes = d3dUtil::CalcConstantBufferByteSize(sizeof(ObjectConstants));

	md3dDevice->CreateConstantBufferView(&cbvDesc,mCbvHeap->GetCPUDescriptorHandleForHeapStart());
}

void MyBox::BuildRootSignature()
{
	CD3DX12_ROOT_PARAMETER slotRootParameter[1];//根签名表

	CD3DX12_DESCRIPTOR_RANGE cbvTable;
	//1：表中的描述符数量，0：将此段描述符区域绑定至此基准着色器寄存器
	cbvTable.Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV,1,0);
	//1：描述符区域的数量；table:指向描述符区域数组的指针
	slotRootParameter[0].InitAsDescriptorTable(1,&cbvTable);
	// 根签名由一组根参数构成
	CD3DX12_ROOT_SIGNATURE_DESC rootSigDesc(1,slotRootParameter,0,nullptr,
	D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);

	ComPtr<ID3DBlob> serializedRootSig = nullptr;
	ComPtr<ID3DBlob> errorBlob=nullptr;
	HRESULT hr=D3D12SerializeRootSignature(&rootSigDesc,D3D_ROOT_SIGNATURE_VERSION_1,
	serializedRootSig.GetAddressOf(),errorBlob.GetAddressOf());

	if (errorBlob!=nullptr)
	{
		::OutputDebugStringA((char*)errorBlob->GetBufferPointer());
	}
	ThrowIfFailed(hr);

	ThrowIfFailed(md3dDevice->CreateRootSignature(
	0,serializedRootSig->GetBufferPointer(),
	serializedRootSig->GetBufferSize(),
	IID_PPV_ARGS(&mRootSignature)
	));
}

void MyBox::BuildShadersAndInputLayout()
{
	HRESULT hr = S_OK;
	mvsByteCode = d3dUtil::CompileShader(L"Shaders\\color.hlsl", nullptr, "VS", "vs_5_0");
	mpsByteCode = d3dUtil::CompileShader(L"Shaders\\color.hlsl", nullptr, "PS", "ps_5_0");

	mInputLayout=
	{
		{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
		{"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}
	};
}

void MyBox::BuildBoxGeometry()
{
	std::array<Vertex,8> verteices=
	{
		Vertex({ XMFLOAT3(-1.0f, -1.0f, -1.0f), XMFLOAT4(Colors::Red) }),
		Vertex({ XMFLOAT3(-1.0f, +1.0f, -1.0f), XMFLOAT4(Colors::Green) }),
		Vertex({ XMFLOAT3(+1.0f, +1.0f, -1.0f), XMFLOAT4(Colors::Blue) }),
		Vertex({ XMFLOAT3(+1.0f, -1.0f, -1.0f), XMFLOAT4(Colors::White) }),
		Vertex({ XMFLOAT3(-1.0f, -1.0f, +1.0f), XMFLOAT4(Colors::Blue) }),
		Vertex({ XMFLOAT3(-1.0f, +1.0f, +1.0f), XMFLOAT4(Colors::White) }),
		Vertex({ XMFLOAT3(+1.0f, +1.0f, +1.0f), XMFLOAT4(Colors::Red) }),
		Vertex({ XMFLOAT3(+1.0f, -1.0f, +1.0f), XMFLOAT4(Colors::Green) })
	};
	std::array<std::uint16_t, 36> indices = 

		{
			// front face
			0, 1, 2,
			0, 2, 3,

			// back face
			4, 6, 5,
			4, 7, 6,

			// left face
			4, 5, 1,
			4, 1, 0,

			// right face
			3, 2, 6,
			3, 6, 7,

			// top face
			1, 5, 6,
			1, 6, 2,

			// bottom face
			4, 0, 3,
			4, 3, 7
	};

	const UINT vbByteSize = (UINT)verteices.size() * sizeof(Vertex);
	const UINT ibByteSize = (UINT)indices.size() * sizeof(std::uint16_t);

	mBoxGeo=std::make_unique<MeshGeometry>();
	mBoxGeo->Name = "boxGeo";

	ThrowIfFailed(D3DCreateBlob(vbByteSize,&mBoxGeo->VertexBufferCPU));
	CopyMemory(mBoxGeo->VertexBufferCPU->GetBufferPointer(),verteices.data(),vbByteSize);

	ThrowIfFailed(D3DCreateBlob(ibByteSize, &mBoxGeo->IndexBufferCPU));
	CopyMemory(mBoxGeo->IndexBufferCPU->GetBufferPointer(), indices.data(), ibByteSize);

	//创建顶点/索引默认缓冲区
	mBoxGeo->VertexBufferGPU = d3dUtil::CreateDefaultBuffer(
	md3dDevice.Get(),mCommandList.Get(),verteices.data(),vbByteSize,mBoxGeo->VertexBufferUploader);
	mBoxGeo->IndexBufferGPU= d3dUtil::CreateDefaultBuffer(
	md3dDevice.Get(),mCommandList.Get(),indices.data(),ibByteSize,mBoxGeo->IndexBufferUploader);
	//缓冲区数据
	//字节跨度
	mBoxGeo->VertexByteStride=sizeof(Vertex);
	mBoxGeo->VertexBufferByteSize=vbByteSize;
	mBoxGeo->IndexFormat=DXGI_FORMAT_R16_UINT;
	mBoxGeo->IndexBufferByteSize=ibByteSize;

	SubmeshGeometry subMesh;
	subMesh.IndexCount=(UINT) indices.size();
	subMesh.StartIndexLocation=0;
	subMesh.BaseVertexLocation=0;
	

	// 一个结构体能够存储一组顶点/索引缓冲区中的多个几何体
	//用下列容器来定义子网格几何体，就能单独绘制其中的子网格
	mBoxGeo->DrawArgs["box"]=subMesh;
}

void MyBox::BuildPSO()
{
	//流水线状态描述
	D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc;
	//将数据的缓冲区用0来填充,使用一块内存区域前对其进行清空处理可以避免内存数据的不确定性。
	ZeroMemory(&psoDesc,sizeof(D3D12_GRAPHICS_PIPELINE_STATE_DESC));
	psoDesc.InputLayout={mInputLayout.data(),(UINT)mInputLayout.size()};
	psoDesc.pRootSignature=mRootSignature.Get();
	psoDesc.VS=
	{
		reinterpret_cast<BYTE*>(mvsByteCode->GetBufferPointer()),
		mvsByteCode->GetBufferSize()
	};
	psoDesc.PS=
	{
		reinterpret_cast<BYTE*>(mpsByteCode->GetBufferPointer()),
		mpsByteCode->GetBufferSize()
	};
	psoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT);	//光栅化状态
	psoDesc.BlendState= CD3DX12_BLEND_DESC(D3D12_DEFAULT);
	psoDesc.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT);
	psoDesc.SampleMask=UINT_MAX;
	psoDesc.PrimitiveTopologyType=D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
	psoDesc.NumRenderTargets=1;
	psoDesc.RTVFormats[0]=mBackBufferFormat;
	psoDesc.SampleDesc.Count= m4xMsaaState?4:1;
	psoDesc.SampleDesc.Quality=m4xMsaaState?(m4xMsaaState-1):0;
	psoDesc.DSVFormat=mDepthStencilFormat;
	ThrowIfFailed(md3dDevice->CreateGraphicsPipelineState(&psoDesc,IID_PPV_ARGS(&mPSO)));


}

bool MyBox::Initialize()
{
	if (!DXApp::Initialize())
	{
		return false;
	}
	//准备初始化命令之前线重置命令列表
	ThrowIfFailed(mCommandList->Reset(mDirectCmdListAlloc.Get(),nullptr));

	BuildDescriptorHeaps();
	BuildConstantBuffers();
	BuildRootSignature();
	BuildShadersAndInputLayout();
	BuildBoxGeometry();
	BuildPSO();

	ThrowIfFailed(mCommandList->Close());
	ID3D12CommandList* cmdLists[]={mCommandList.Get()};
	mCommandQueue->ExecuteCommandLists(_countof(cmdLists),cmdLists);

	FlushCommandQueue();

	return true;
}

int WINAPI WinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPSTR lpCmdLine, _In_ int nShowCmd)
{

	// Enable run-time memory check for debug builds.
#if defined(DEBUG) | defined(_DEBUG)
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
	try
	{
		MyBox theApp(hInstance);
		if (!theApp.Initialize())
			return 0;

		return theApp.Run();
	}
	catch (DxException& e)
	{
	
		MessageBox(nullptr, e.ToString().c_str(), L"HR Failed", MB_OK);

		return 0;
	}



}

DX学习笔记（三）：渲染流水线

发表于 2020-06-24 更新于 2021-08-02 分类于 graphics Changyan：

本文字数： 12k 阅读时长 ≈ 11 分钟

渲染流水线

平行线最终会相交于消失点，又称为灭点

物体重叠：即不同命的物体能够遮挡住其后侧物体的局部

3D实体对象是通过三角形网格来近似表示的

颜色

分量式乘法:(r,g,b)*(a,b,c)=(ra,gb,bc)

128位颜色

每个分量用浮点表示，即4D向量 (r,g,b,a)

0<=r,g,b,a<=1

DirectXMath库对分量式乘法的支持

1	XMVECTOR XM_CAKKCIBV XMColorModulate (FXMVECTOR C1,FXMVECTOR C2);//返回C1*C2

32位颜色

每个分量仅分配1个字节，因此每个占用8字节的颜色分量就分别描述256种不同的颜色强度

即0代表无强度，256代表最大强度

DirectXMath库(include<DirectXPackedVector.h>)在DirectX::PackedVector命名空间提供了相应函数

namespace DirectX
{
    namespace PackedVector
    {
        struct XMCOLOR
        {
            union
            {
                struct
                {
                    uint8_t b;  // Blue:    0/255 to 255/255
            		uint8_t g;  // Green:   0/255 to 255/255
            		uint8_t r;  // Red:     0/255 to 255/255
            		uint8_t a;  // Alpha:   0/255 to 255/255
                    
                };uint32_t c;
                XMCOLOR() = default;

    			XMCOLOR(const XMCOLOR&) = default;
                XMCOLOR& operator=(const XMCOLOR&) = default;

                XMCOLOR(XMCOLOR&&) = default;
                XMCOLOR& operator=(XMCOLOR&&) = default;

                XM_CONSTEXPR XMCOLOR(uint32_t Color) : c(Color) {}
                XMCOLOR(float _r, float _g, float _b, float _a);
                explicit XMCOLOR(_In_reads_(4) const float *pArray);

                operator uint32_t () const { return c; }

                XMCOLOR& operator= (const uint32_t Color) { c = Color; return *this; }
            }
        }
    }
}

通过将[0,255]映射到[0,1]即可完成32位到128位的转换

转换函数

1	XMVECTOR XM_CALLCONV XMLoadColor( const XMCOLOR* pSource);

1	void XM_CALLCONV XMStoreColor( XMCOLOR* pDestination, FXMVECTOR V );

渲染流水线概述

渲染流水线(rendering pipeline)是以摄像机位观察视角而生成的2D图像的一系列完整步骤

输入装配阶段

输入装配阶段：从显存中读取集合数据(顶点和索引，vertex and index)

再装配为几何图元（几何基元），如三角形和线条

顶点缓冲区：将顶点与渲染流水线绑定的特殊结构体

图元拓扑(primitive topology)

1 2	virtual void STDMETHODCALLTYPE IASetPrimitiveTopology( _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology) = 0;

typedef 
enum D3D_PRIMITIVE_TOPOLOGY
    {
        D3D_PRIMITIVE_TOPOLOGY_UNDEFINED	= 0,
        D3D_PRIMITIVE_TOPOLOGY_POINTLIST	= 1,
        D3D_PRIMITIVE_TOPOLOGY_LINELIST	= 2,
        D3D_PRIMITIVE_TOPOLOGY_LINESTRIP	= 3,
        D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST	= 4,
        D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP	= 5,
        D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ	= 10,
        D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ	= 11,
        D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ	= 12,
        D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ	= 13,
        D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST	= 33,
        D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST	= 34,
        D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST	= 35,
        D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST	= 36,
        D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST	= 37,
        D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST	= 38,
        D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST	= 39,
        D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST	= 40,
        D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST	= 41,
        D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST	= 42,
        D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST	= 43,
        D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST	= 44,
        D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST	= 45,
        D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST	= 46,
        D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST	= 47,
        D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST	= 48,
        D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST	= 49,
        D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST	= 50,
        D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST	= 51,
        D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST	= 52,
        D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST	= 53,
        D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST	= 54,
        D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST	= 55,
        D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST	= 56,
        D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST	= 57,
        D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST	= 58,
        D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST	= 59,
        D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST	= 60,
        D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST	= 61,
        D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST	= 62,
        D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST	= 63,
        D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST	= 64,
        D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED	= D3D_PRIMITIVE_TOPOLOGY_UNDEFINED,
        D3D10_PRIMITIVE_TOPOLOGY_POINTLIST	= D3D_PRIMITIVE_TOPOLOGY_POINTLIST,
        D3D10_PRIMITIVE_TOPOLOGY_LINELIST	= D3D_PRIMITIVE_TOPOLOGY_LINELIST,
        D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP	= D3D_PRIMITIVE_TOPOLOGY_LINESTRIP,
        D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
        D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
        D3D10_PRIMITIVE_TOPOLOGY_LINELIST_ADJ	= D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ,
        D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ	= D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ,
        D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ,
        D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ,
        D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED	= D3D_PRIMITIVE_TOPOLOGY_UNDEFINED,
        D3D11_PRIMITIVE_TOPOLOGY_POINTLIST	= D3D_PRIMITIVE_TOPOLOGY_POINTLIST,
        D3D11_PRIMITIVE_TOPOLOGY_LINELIST	= D3D_PRIMITIVE_TOPOLOGY_LINELIST,
        D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP	= D3D_PRIMITIVE_TOPOLOGY_LINESTRIP,
        D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
        D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
        D3D11_PRIMITIVE_TOPOLOGY_LINELIST_ADJ	= D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ,
        D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ	= D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ,
        D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ,
        D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ	= D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ,
        D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST,
        D3D11_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST	= D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST
    } 	D3D_PRIMITIVE_TOPOLOGY;

示例

//通过线列表来绘制对象
mCommandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_LINELIST);
//通过三角形列表来绘制对象
mCommandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
//通过三角形带来绘制对象
mCommandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);

点列表 D3D_PRIMITIVE_TOPOLOGY_POINTLIST
线条带 D3D_PRIMITIVE_TOPOLOGY_LINESTRIP
线列表 D3D_PRIMITIVE_TOPOLOGY_LINELIST
三角形带 D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP

剔除(culling)问题：奇数与偶数三角形的绕序(环绕顺序)即装配图元的顶点顺序是不同的

CPU会对偶数三角形的前两个顶点顺序进行调换已达到有奇数三角形绕序相同

正确的应该是后两个顶点顺序调换，而OpenGL中才是前两个顶点调换

三角形列表

D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST

三角形列表与三角形带的区别是，三角形列表的三角形可以彼此分离，所以每n*3个顶点组成n个三角形

具有邻接数据的图元拓扑

对于有邻接数据的三角形列表，每个三角形都有3个与之相邻的邻接三角形

借助顶点缓冲区和索引缓冲区将它们随主三角形一并提交至渲染流水线

并且要把拓扑类型指定为D3D12_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ让渲染流水线知道如何以顶点缓冲区的顶点来构建主三角形和其邻接三角形；

邻接图元的顶点只作为集合着色器的输入数据，并不会被绘制

索引

Vertex quad[6]={
    v0,v1,v2,//三角形0
    v0,v2,v3 //三角形1
}；

绕序：为三角形指定顶点顺序

用顶点列表和索引列表组合起来构成三角形

如

Vertex v[9]={v0,v1,v2,v3,v4,v5,v6,v7,v8};
UINT indexList[24]={
    0,1,2,
    0,2,3,
    0,3,4,
    0,4,5,
    0,5,6,
    0,6,7,
    0,7,8,
    0,8,1
}

顶点着色阶段

世界变换：将局部坐标系内的坐标转换到世界坐标系
世界矩阵：上述变换的矩阵

$$
W=SRT
$$

观察空间:相机的局部坐标系，亦称视觉空间、摄像机空间等
取景变换：世界空间至观察空间的变换；此变换的矩阵叫做观察矩阵

观察矩阵函数

inline XMMATRIX XM_CALLCONV XMMatrixLookAtLH
(
    FXMVECTOR EyePosition, 
    FXMVECTOR FocusPosition, 
    FXMVECTOR UpDirection
)

示例

XMVECTOR eyePos=XMVectorSet(100,100,100,1);
XMVECTOR target=XMVectorZero();
XMVECTOR up=XMVectorSet(0,1,0,0);
XMMATRIX V=XMMatrixLookAtLH(eyePos,target,up);//返回观察矩阵
XMVECTOR v2=XMVector3TransformCoord(target,V);
cout<<v2;//输出得到(0,0,173.2),即在观察空间的坐标

顶点的投影线：顶点到观察点的连线
透视投影变换：3D顶点v变换至其投影线与3D投影平面的交点v^、

近平面(近裁剪面)n,远平面f，垂直视场角α，纵横比r，4个参数定义了以原点作为投影的中心，以Z轴进行观察的平截头体

纵横比
$$
r=w/h
$$
w:投影窗口的宽度

h:投影窗口的高度

如果后台缓冲区与投影窗口纵横比不一致，在映射的过程中会产生非均匀缩放（不等比例缩放），导致图像拉伸

NDC：规格化设备坐标(Normalized Device Coordinates)
透视除法（齐次除法）：顶点与投影矩阵相乘以后，对每个坐标除以w=z
归一化深度值：通过函数 g(z)把z坐标从[n,f]映射到区间[0,1]

$$
g(z)=A+ {B \over z}
$$

透视投影矩阵

$$
P=\begin{bmatrix}1\over rtan({\alpha \over 2}) & 0 & 0 & 0\
0 & 1\over{tan({\alpha\over 2})} & 0 & 0 \
0 & 0 & f\over {f-n} & 1 \
0 & & 0 & -nf\over{f-n} & 0
\end{bmatrix}
$$

在顶点乘以投影矩阵后，集合体会处于所谓的齐次裁剪空间或者投影空间

完成透视除法以后，便是**规格化设备坐标(NDC)**了

XMMatrixPerspectiveFovLH

inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveFovLH
(
    float FovAngleY, //用弧度值表示的垂直视场角
    float AspectRatio, //纵横比：宽度/高度
    float NearZ, //近平面距离
    float FarZ//到远平面距离
)

示例

1 2	XMMATRIX M2=XMMatrixPerspectiveFovLH(0.25f*XM_PI,1092/1080,1.0,1000); cout<<M2;

2.41421 0 0 0
0 2.41421 0 0
0 0 1.001 1
0 0 -1.001 0

曲面细分阶段

利用镶嵌化处理技术对网格中的三角形进行细分，以此来增加物体表面上的三角形数量。

再将这些新增的三角形偏移到适当的位置，使网格表现出更加细腻的细节

曲面细分的优点

实现LOD
在内存中只维护低模，在有需求时动态增添三角形，从而节省资源
处理动画和物理时使用低模，渲染时使用处理过的高模

几何着色器阶段

几何着色器阶段接受输入是完整的图元

与顶点着色器相比，几何着色器可以创建或者修改几何体

比如，将一个点或者一条线扩展为一个四边形

裁剪

对视锥体之外的物体进行裁剪

苏泽兰-霍奇曼裁剪算法

光栅化阶段

光栅化阶段(RS,栅格化)：投影主屏幕上的3D三角形计算出对应的像素颜色

视口变换：裁剪完成后，硬件通过透视除法将物体从齐次空间变换为规格化设备坐标（NDC）。此后顶点x、y坐标会以像素单位表示
背面剔除：将背面朝向的三角形从渲染流水线中除去
透视矫正插值：为得到2D空间的顶点的插值属性，对3D空间的三角形属性进行线性插值，即利用三角形属性计算出内部像素的属性
像素着色器阶段(pixel shader)：针对每个像素片段进行处理，根据顶点的差值属性作为输入来计算像素颜色，亦可实现如逐像素光照(per-pixel lighting)、反射以及阴影等复杂效果
输入合并阶段：上述阶段生成的像素片段送至渲染流水线的输出合并阶段(OM)。丢弃部分像素(如未通过深度测试等)，剩下的写入后台缓冲区，执行混合(blend)操作（透明效果也混合实现的）

DX学习笔记（一）：数学基础

发表于 2020-06-23 更新于 2021-08-02 分类于 graphics Changyan：

本文字数： 10k 阅读时长 ≈ 9 分钟

向量代数

向量

DirectX3D采用的左手坐标系

左手坐标系：伸出左手，手指方向对准X轴正方向，弯曲手指对象Y轴正方向，大拇指指的就是Z轴正方向

向量的基本运算

两个向量相等。即u=v。当且仅当u和v的每个分量相等，即u_x=v_x,u_y=v_y, u_z=v_z
向量的加法即两个向量对应分量都相加
向量与标量相乘即每一个分量与标量相乘
向量减法与加法类似

向量加法的几何意义u+v，即u的尾部与v的头部重合

向量的长度和单位向量

3D向量的模可以用2次毕达哥拉斯定理（勾股定理）计算得到

一个向量的长度变为单位长度称为向量的规范化（normalizing）,具体实现方法是

点积

点积（dot product）是一种计算结果为标量值的向量乘法

如果u·v=0，那么u和v正交（垂直）
如果u·v>0,那么夹角为锐角，即小于90°
如果>0,那么夹角为钝角

正交投影

即向量p是v在n向量上的投影

一般的投影公式如下

正交化

如果向量集里面所有向量都相互正交，那么此向量集是规范正交

格拉姆-施密特正交化

从文字上描述即，将向量v添加到规范正交集中时，需要用v减去这个规范正交集中的所有其他向量{w1,w2…}方向上的分量投影，这样确保新加入的v与该集合中的其他放量相互正交

假设有向量集{v0,v1}，将其规范正交至集{w0,w1}

则需要进行如下操作

如果是三维向量集{v0,v1,v2}，至规范正交集{w0,w1,w2}

则进行如下操作

叉积

叉积公式

两个向量叉积的意义即得到正交于两个向量的向量，采用的左手坐标系，即手指指向一个向量，通过向内弯曲小于等于180°的角度后到达另外一个向量，则大拇指方向是叉积所得向量的方向

用叉积类规范正交化

点

点（x,y,z）即从原点至该点的向量

用DirectXMath库

DirectXMath变量的使用规范

局部变量或全局变量用XMVECTOR类型
对于类中的数据成员，用XMFLOAT2\XMFLOAT3和XMFLOAT4类型
在运算之前，通过加载函数将XMFLOATn类型转换成XMVECTOR类型
用XMVECTOR实例来进行运算
通过存储函数将XMVECTOR类型转换为XMFLOATn类型

加载方法和存储方法

//将数据从XMFLOAT2类型加载到XMVECTOR类型
XMVECTOR XM_CALLCONV XMLoadFloat2(const XMFLOAT2* pSource);
//将数据从XMFLOAT3类型加载到XMVECTOR类型，XMFLOAT4类似
XMVECTOR XM_CALLCONV XMLoadFloat3(const XMFLOAT3* pSource);
//将数据从XMVECTOR类型存储到XMFLOAT2类型，XMFLOAT3以及XMFLOAT4方法类似
void XM_CALLCONV XMStoreFloat2(XMFLOAT2* pDestination,FXMVECTOR V);
//********************//
//得到XMVECTOR实例中的一个分量或者将一个方脸转换为XMVECTOR类型
float XM_CALLCONV XMVectorGetX(FXMVECTOR V);
float XM_CALLCONV XMVectorGetY(FXMVECTOR V);
float XM_CALLCONV XMVectorGetZ(FXMVECTOR V);
float XM_CALLCONV XMVectorGetX(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 参数用类型 FXMVECTOR
第四个 XMVECTOR 参数用 GXMVECTOR
第5、6个 XMVECTOR 参数用 HXMVECTOR
其余的 XMVECTOR 参数用 CXMVECTOR

在32位windows系统，编译器将根据**_fastcall**调用约定将前3个XMVECTOR参数传递到寄存器，其余放到栈

在32位windows系统，编译器将根据**_vectorcall**调用约定将前6个XMVECTOR参数传递到寄存器，其余放到栈上

其余平台上的定义，可以参见 DirectXMath库文档中的 Library Internals下的 Calling Converntions 部分的[DirectXMath]

常向量

XMVECTOR类型的常量实例用 XMVECTORF32 表示

1	static const XMVECTORF32 v1 = { 0.5f,1.0f,1.0f,1.0f };

XMVECTORF32是一种16字节对齐的结构体，数学库中有将他转换至XMVECTOR类型的运算符

另外也可以用XMVECTORU32类型来创建由证书数据构成的XMVECTOR常向量

1	static const XMVECTORU32 v2 = { 1,2,3,4 };

重载运算符

XMVECTOR类型针对向量的加法、减法和标量乘法都重载了运算符，如下

其他

DirectXMath库定义了一组于PI有关的常用数学常量近似值

另外还有角度和弧度之间的转化以及比较大小的函数

Setter函数

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

//返回零向量
XMVECTOR XM_CALLCONV XMVectorZero();
//返回{1，1，1，1}
XMVECTOR XM_CALLCONV XMVectorSplatOne();
//返回{x,y,z,w}
XMVECTOR XM_CALLCONV XMVectorSet(float x,float y,float z,float w);
//返回{value),value),value),value)}
XMVECTOR XM_CALLCONV XMVectorReplicate(float value);
//返回{Vx，Vx，Vx，Vx}，同理；用SplateY，SplayteZ可以返回P{Vy...},或者{Vz..}
XMVECTOR XM_CALLCONV XMVectorSplateX(FXMVECTOR V);

使用案例

#include <DirectXMath.h>
#include <DirectXPackedVector.h>
#include <stdlib.h>
#include <iostream>

using namespace DirectX;
using namespace DirectX::PackedVector;
using namespace std;


// 重写了<<运算符，使得cout函数可以输出XMVECTOR
ostream& XM_CALLCONV operator<<(ostream& os, FXMVECTOR v)
{
	XMFLOAT4 dest;
	XMStoreFloat4(&dest, v);
	os << "(" << dest.x << "," << dest.y << "," << dest.z <<","<<dest.w<< ")" << endl;
	return os;
}

int main()
{

	if (!XMVerifyCPUSupport())
	{
		cout << "directx math not supported" << endl;
		return 0;
	}

	static const XMVECTORF32 v1 = { 0.5f,1.0f,1.0f,1.0f };
	XMVECTOR v2 = XMVectorReplicate(0.99f);
	XMVECTOR v3 = { .5f,.5f,.5f,.5f };
	XMVECTOR v4 = XMVectorSet(1, 2, 3, 4);
	XMVECTOR v5 = XMVectorSplatOne();
	XMVECTOR v6 = XMVectorZero();
	XMVECTOR v7 = XMVectorSplatZ(v4);
	cout << v1 << v2 << v3 << v4 << v5 << v6 << v7;
	


	system("pause");
	return 0;
}

向量函数

XMVECTOR v1 = XMVectorSet(1, 1, 1, 4);
	XMVECTOR v2 = XMVectorSet(-1, -1, -1, 5);
	XMVECTOR v3 = XMVectorSet(1, 0, 0 ,0);
	XMVECTOR a = XMVector4Length(v1);//||v1||2,2_范数，即平方和的更号
	XMVECTOR b = XMVector4LengthSq(v1);//||v1||1,1_范数，即平方和
	XMVECTOR c = v1 - v2;//减法
	XMVECTOR d = 10 * v1;//乘法
	XMVECTOR e = XMVector4Normalize(v1);//标准化，即v1/|v1|
	XMVECTOR f = XMVector3Dot(v1,v2);//v1·v1
	XMVECTOR g = XMVector3Cross(v1, v2);//v1*v1
	XMVECTOR projw, perpw;
	XMVector3ComponentsFromNormal(&projw, &perpw, v1, v3);//求v1在v3的proj和perp
	XMVECTOR angle = XMVector4AngleBetweenVectors(v1, v2);//2个向量的夹角

cout << a<<b<<c<<d<<e<<f<<g<<projw<<perpw<<angle;

浮点数的误差

1 2	XMVector Epsilon={0.1，0.1，0.1，0.1}； bool IsEqual = XMVectorNearEqual(v1, v2，Epsilon);//约等于来解决

矩阵代数

定义

m*n的矩阵M，即由m行，n列构成的矩形阵列

A_1.*
A_*.1

乘法

矩阵AxB乘法的前提条件：A的列数必须于B的行数相同

乘法公式

即矩阵A的第i个行向量于B的第j个列向量点积

行列数不相等的矩阵乘法不满足交换律即 AB≠BA

向量于矩阵乘法

转置矩阵

转置矩阵（transpose matrix）是将原矩阵阵列的行与列进行互换即mn的矩阵变成nm的矩阵

**M **的转置矩阵记作 M^t

转置矩阵具有下列性质

单位矩阵

单位矩阵(identity matrix)是一种主对角线上的元素都是1，其他元素都是0的方阵，如

任何单位与单位矩阵相乘，得到的依然是原来的矩阵，而且满足交换律

MI=IM=M

矩阵的行列式

行列式记作： det A

当且仅当det A≠0时，方阵A是可逆的

余子阵

n x n的矩阵A，余子阵（minor matrix） 即从A中去除第 i 行和第 j 列的**(n-1)*(n-1)**矩阵

行列式

对于2 x 2 的矩阵来说，行列式公式为：

3 x 3的矩阵，行列式公式为：

4 x 4的矩阵，行列式公式为：

案例：

一个矩阵的行列式就是一个平行多面体的（定向的）体积，这个多面体的每条边对应着对应矩阵的列。如果学生得知了这个秘密（在纯粹的代数式的教育中，这个秘密被仔细的隐藏了起来），那么行列式的整个理论都将成为多重线性形式理论的一部分。倘若用别的方式来定义行列式，任何敏感的人都将会永远痛恨诸如行列式，Jacobian式，以及隐函数定理这些东西。

——俄国数学家阿诺尔德（Vladimir Arnold）《论数学教育》

伴随矩阵

如果A中的每个元素分别计算出C_ij,并将它至于矩阵C_A中的第 i 行，第 j 列，那么将获得矩阵A的 代数余子式矩阵(cofactor matrix of A)

取矩阵C_A的转置矩阵，得到矩阵A的伴随矩阵（adjoint matrix of A），记作

逆矩阵

只有方阵才有逆矩阵
n x n矩阵M的逆也是一个n x n的矩阵，记作 M^-1
不是每个方阵都有逆矩阵，存在逆矩阵的方阵称为可逆矩阵（invertible matrix），不存在逆矩阵的叫做奇异矩阵（singular matrix）
可逆矩阵的逆矩阵是唯一的
可逆矩阵有逆矩阵相乘等到单位方阵： MM^-1=M^-1M=I，矩阵与其逆矩阵妈祖交换律

逆矩阵的推导公式

案例，

DirectXMath库处理矩阵阵列

ostream& XM_CALLCONV operator<<(ostream& os, FXMVECTOR v)
{
	XMFLOAT4 dest;
	XMStoreFloat4(&dest, v);
	os << "(" << dest.x << "," << dest.y << "," << dest.z <<","<<dest.w<< ")" ;
	return os;
}

ostream& XM_CALLCONV operator<<(ostream& os, FXMMATRIX v)
{

	for (int i=0;i<4;i++)
	{
		os << XMVectorGetX(v.r[i]) << "\t";
		os << XMVectorGetY(v.r[i]) << "\t";
		os << XMVectorGetZ(v.r[i]) << "\t";
		os << XMVectorGetW(v.r[i]) << "\t";
		os << endl;
	}
	return os;

}

int main()
{

	if (!XMVerifyCPUSupport())
	{
		cout << "directx math not supported" << endl;
		return 0;
	}
	XMMATRIX A
	(
		1.0f, 0.0f, 0.0f, 0.0f,
		0.0f, 2.0f, 0.0f, 0.0f,
		0.0f, 0.0f, 4.0f, 0.0f,
		1.0f, 2.0f, 3.0f, 1.0f
	);

		XMMATRIX B = XMMatrixIdentity();//单位矩阵，斜线都是1
	XMMATRIX C = A * B;//矩阵乘法，AI=A；
	XMMATRIX D = XMMatrixTranspose(A);//转置矩阵，行列反转
	XMVECTOR det = XMMatrixDeterminant(A);//得到（det A,det A,det A,det A）
	XMMATRIX E = XMMatrixInverse(&det, A);//返回M逆矩阵
	XMMATRIX F = A * E;//矩阵与逆矩阵乘积等于单位矩阵





	cout << A << endl << B << endl << C << endl << D << endl << E << endl << det << endl << F;

	system("pause");
	return 0;
}

变换

线性变换

线性变换函数满足

线性变换函数公式

矩阵表示法

**u=(x,y,z)**也可以写作

矩阵表示法公式

R³,标准基向量

i=(1,0,0), j=(0,1,0), k=(0,0,1)

矩阵表示法公式2

根据线性组合，上述公式可以改写成

线性变换的矩阵表示法

我们称矩阵 A是线性变换的矩阵表示法

缩放

定义

S就是一种线性变换

缩放变换的矩阵表达式

缩放矩阵的逆矩阵

案例

旋转

旋转矩阵基础公式

上述公式里，c=cosθ 而且 s=sinθ
旋转矩阵有个特性：每个行向量都为单位长度且两两正交，即这些行向量都是规范正交(orthonormal)
若一个矩阵的行向量都是规范正交的，则此矩阵为正交矩阵（orthogonal matrix）

正交矩阵的逆矩阵

通俗公式

如果选择绕x、y、z轴旋转，即分别取 n =（1，0，0）、n =（0，1，0）、n =（0，0，1），那么对应的旋转矩阵是

案例

仿射变换

齐次坐标

（x,y,z,0）表示向量
（x,y,z,1）表示点

仿射变换定义

仿射变换：一个线性变换加上一个平移变量 b,即

α(u)=τ(u)+b

或者用矩阵表示法,A是一个线性变换的矩阵表示

如果w=1把坐标扩充为齐次坐标，那么把上述公式简化成

平移

恒等变换

恒等变换是一种直接返回其输入参数的线性变换，如 I(u)=u

如果将平移变换定义为仿射变换，贼其中的线性变换就是一种恒等变换，即

平移矩阵

平移矩阵的逆矩阵

案例

缩放和旋转的放射矩阵

如果放射变换的 b=0 ,则放射变换就是线性变换
意味着，可以通过一个 4 x 4 的放射矩阵表达任意线性变换

4x4的缩放矩阵

4x4的旋转矩阵

仿射变换矩阵的几何意义

变换的复合

假设S为缩放矩阵，T为平移矩阵，R为旋转矩阵

因为矩阵乘法（不满足交换律），所以我么可以定义C=SRT，即把3个矩阵变成1个，方便计算

坐标变换

坐标变换矩阵/标架变换矩阵公式

结合律

3个标架F,G,H
A：F转换到G的变换矩阵
B：G转换到H的变换矩阵
p_F:F中的一个向量
求：此向量在标架H中的坐标P_H

***(p_F***A)B=P_H

(p_G)B=P_H

由于矩阵乘法满足结合律，所以

p_F(AB)=P_H

逆矩阵

p_FA=P_H

P_F=p_HA^-1

变换矩阵与坐标变换矩阵

在数学上，可以将改变几何体的变换解释为坐标变换，反之亦然

DirectXMath库的变换函数

#pragma 
#include <windows.h>
#include <iostream>
#include <DirectXMath.h>
#include <DirectXPackedVector.h>

using namespace std;
using namespace DirectX;
using namespace DirectX::PackedVector;



ostream& operator<<( ostream& os, FXMVECTOR v)
{

	XMFLOAT4 value;
	XMStoreFloat4(&value, v);
	os << "(" << value.x << "," << value.y << "," << value.z << "," << value.w << ")" << endl;
	return os;
}

ostream& operator<<(ostream& os, FXMMATRIX M)
{
	for (int i=0;i<4;i++)
	{
		os  << XMVectorGetX(M.r[i]) << "\t" ;
		os  << XMVectorGetY(M.r[i]) << "\t" ;
		os  << XMVectorGetZ(M.r[i]) << "\t" ;
		os  << XMVectorGetW(M.r[i]) << "\t" ;
		os << endl;
	}
	return os;
}


int main()
{

	XMMATRIX m1 =
	{
		1.0f, 1.0f, 1.0f, 1.0f,
		2.0f, 2.0f, 2.0f, 2.0f,
		3.0f, 3.0f, 3.0f, 3.0f,
		4.0f, 4.0f, 4.0f, 4.0f
	};
	//缩放系数
	XMMATRIX Scale1 = XMMatrixScaling(1.0f, 2.0f, 3.0f);//缩放矩阵1
	XMVECTOR v1 = XMVectorSet(0.1, 0.1, 0.1, 0.1);
	XMMATRIX Scale2 = XMMatrixScalingFromVector(v1);//缩放矩阵2，根据Vector

	XMMATRIX RotX = XMMatrixRotationX(90.f);//X轴旋转矩阵
	XMMATRIX RotY = XMMatrixRotationY(45.f);
	XMMATRIX RotZ = XMMatrixRotationZ(-180.f);
	XMVECTOR Axis= XMVectorSet(1, 0, 0, 0);
	XMMATRIX RotAxis = XMMatrixRotationAxis(Axis, 45.f);//根据自定义轴旋转
	XMMATRIX TransT = XMMatrixTranslation(100.f, 10.f, -20.f);//位移矩阵
	XMVECTOR vTransCoord = XMVector3TransformCoord(v1, TransT);//移动向量
	XMVECTOR vTransNormal = XMVector3TransformNormal(v1, TransT);

	cout << "m=" << endl << m1  << endl;
	cout << "m*scale1=" << endl<< m1* Scale1 << endl;
	cout << "m*scale2==" << endl << m1*Scale2 << endl;
	cout << "RotX==" << endl << RotX << endl;
	cout << "m*RotX==" << endl << m1 * RotX << endl;
	cout << "v1:TransCoord==" << endl << vTransCoord << endl;
	cout << "v1:TransNormal==" << endl << vTransNormal << endl;
	system("pause");
	return 0;
}

Markdown(Typora)数学公式

发表于 2020-06-23 更新于 2021-08-02 分类于 math Changyan：

本文字数： 4.4k 阅读时长 ≈ 4 分钟

Ctrl+Shift+M激活公式

上下标

a^2+\ b_{y_3}

$$
a^2+\ b_{y_3}
$$

括号

中小括号

(a+b)*[c+2]
$$
(a+b)*[c+2]
$$

大括号需要加\

\{1,2,3 \}
$$
{1,2,3 }
$$

尖括号

\langle x \rangle
$$
\langle x \rangle
$$

上下取整

\lceil x \rceil+\lfloor y\rfloor
$$
\lceil x \rceil+\lfloor y\rfloor
$$

特殊括号

\begin{pmatrix} 1\ 2\\ 3\ 4 \end{pmatrix}\\ \begin{bmatrix} 1\ 2\\ 3\ 4 \end{bmatrix}\\ \begin{Bmatrix} 1\ 2\\ 3\ 4 \end{Bmatrix}\\ \begin{vmatrix} 1& 2\\ 3& 4 \end{vmatrix}\\ \begin{Vmatrix} 1& 2\\ 3& 4 \end{Vmatrix}\\
$$
\begin{pmatrix} 1\ 2\ 3\ 4 \end{pmatrix}\
\begin{bmatrix} 1\ 2\ 3\ 4 \end{bmatrix}\
\begin{Bmatrix} 1\ 2\ 3\ 4 \end{Bmatrix}\
\begin{vmatrix} 1& 2\ 3& 4 \end{vmatrix}\
\begin{Vmatrix} 1 & 2\ 3 & 4 \end{Vmatrix}\
$$

希腊字母

1.\alpha\ A\\ 2.\beta\ B\\ 3.\gamma\ \Gamma\\ 4.\delta\ \Delta\\ 5.\epsilon\ E\\ 6.\zeta\ Z\\ 7.\eta\ H\\ 8.\theta\ \Theta\\ 9.\iota\ I\\ 10.\kappa\ K\\ 11.\lambda\ \Lambda\\ 12.\mu\ M\\ 13.\nu\ N\\ 14.\xi\ \Xi\\ 15.\omicron\ O\\ 16.\pi\ \Pi\\ 17.\rho\ P\\ 18.\sigma\ \Sigma\\ 19.\tau\ T\\ 20.\upsilon\ \Upsilon\\ 21.\phi\ \Phi\\ 22.\chi\ X\\ 23.\psi\ \Psi\\ 24.\omega\ \Omega\\
$$
1.\alpha\ A\
2.\beta\ B\
3.\gamma\ \Gamma\
4.\delta\ \Delta\
5.\epsilon\ E\
6.\zeta\ Z\
7.\eta\ H\
8.\theta\ \Theta\
9.\iota\ I\
10.\kappa\ K\
11.\lambda\ \Lambda\
12.\mu\ M\
13.\nu\ N\
14.\xi\ \Xi\
15.\omicron\ O\
16.\pi\ \Pi\
17.\rho\ P\
18.\sigma\ \Sigma\
19.\tau\ T\
20.\upsilon\ \Upsilon\
21.\phi\ \Phi\
22.\chi\ X\
23.\psi\ \Psi\
24.\omega\ \Omega\
$$

根式分式

\sqrt[x+y]{\frac ab}+\sqrt{c+2\over 50+x}
$$
\sqrt[x+y]{\frac ab}+\sqrt{c+2\over 50+x}
$$

字体

ABCabc+\ \mathbb{ ABCabc}+\ \Bbb{ ABCabc黑板粗体}\\ ABCabc+\mathbf{ABCabc黑体}\\ ABCabc+\mathtt{ABCabc打印字体} \\ ABCabc+\mathrm{ABCabc罗马字体} \\ ABCabc+\mathscr{ABCabc手写字体} \\ ABCabc+\mathfrak{ABCabc德国字体Fraktur}
$$
ABCabc+\ \mathbb{ ABCabc}+\ \Bbb{ ABCabc黑板粗体}\
ABCabc+\mathbf{ABCabc黑体}\
ABCabc+\mathtt{ABCabc打印字体} \
ABCabc+\mathrm{ABCabc罗马字体} \
ABCabc+\mathscr{ABCabc手写字体} \
ABCabc+\mathfrak{ABCabc德国字体Fraktur}
$$

表格

\begin{array}{c|lcr} n & \text{Left} & \text{Center} & \text{Right} \\ \hline 1 & 0.24 & 1 & 125 \\ 2 & -1 & 189 & -8 \\ 3 & -20 & 2000 & 1+10i \\ \end{array}
$$
\begin{array}{c|lcr} n & \text{Left} & \text{Center} & \text{Right} \ \hline 1 & 0.24 & 1 & 125 \ 2 & -1 & 189 & -8 \ 3 & -20 & 2000 & 1+10i \ \end{array}
$$

矩阵

\begin{matrix} 1 & x & x^2 \\ 1 & y & y^2 \\ 1 & z & z^2 \end{matrix}
$$
\begin{matrix} 1 & x & x^2 \ 1 & y & y^2 \ 1 & z & z^2 \end{matrix}
$$

向量等顶部符号

\vec{abc} \ ,\overline b\ ,\overrightarrow{cde} \ ,\dot c\ , \dot {adb}\ ,\ddot{acd}\ ,\dddot{adfe}
$$
\vec{abc} \ ,\overline b\ ,\overrightarrow{cde} \ ,\dot c\ , \dot {adb}\ ,\ddot{acd}\ ,\dddot{adfe}
$$

对其

需要使用&来指示需要对齐的位置

\begin{align} \sqrt{37} & = \sqrt{\frac{73^2-1}{12^2}} \\ & = \sqrt{\frac{73^2}{12^2} \cdot \frac{73^2-1}{73^2}} \\ & = \frac{73}{12} \sqrt{1 - \frac{1}{73^2}} \\ & \approx \frac{73}{12} \left( 1 - \frac{1}{2 \cdot 73^2} \right) \end{align}
$$
\begin{align} \sqrt{37} & = \sqrt{\frac{73^2-1}{12^2}} \ & = \sqrt{\frac{73^2}{12^2} \cdot \frac{73^2-1}{73^2}} \ & = \frac{73}{12} \sqrt{1 - \frac{1}{73^2}} \ & \approx \frac{73}{12} \left( 1 - \frac{1}{2 \cdot 73^2} \right) \end{align}
$$

分类表达式

f(n) = \begin{cases} n/2, & \text{if $n$ is even} \\ 3n+1, & \text{if $n$ is odd} \end{cases}
$$
f(n) = \begin{cases} n/2, & \text{if $n$ is even} \ 3n+1, & \text{if $n$ is odd} \end{cases}
$$
\left. \begin{array}{l} \text{if $n$ is even:} & n/2 \\ \text{if $n$ is odd:} & 3n+1 \end{array} \right\} = f(n)
$$
\left. \begin{array}{l} \text{if $n$ is even:} & n/2 \ \text{if $n$ is odd:} & 3n+1 \end{array} \right} = f(n)
$$

公式标记与引用

a:= x^2-y^3 \tag{公式1}\label{公式1}
$$
a:= x^2-y^3 \tag{公式1}\label{公式1}
$$
a+y^3 \stackrel{\eqref{公式1}}=x^2

$$
a+y^3 \stackrel{\eqref{公式1}}=x^2
$$

其他

\to \rightarrow \leftarrow \Rightarrow \Leftarrow \mapsto
$$
\to \rightarrow \leftarrow \Rightarrow \Leftarrow \mapsto
$$
\lt \gt \le \ge \neq
$$
\lt \gt \le \ge \neq
$$

\sin x\\ \arctan_y\\ \lim_{1\to\infty}\\
$$
\sin x\
\arctan_y\
\lim_{1\to\infty}\
$$
\sum_1^n\ ,\int_1^{x+y}\
$$
\sum_1^n\ ,\int_1^{x+y}
$$

合集图片

20190703164359871

DX学习笔记（二）：DX初始化

发表于 2020-06-22 更新于 2021-08-02 分类于 graphics Changyan：

本文字数： 43k 阅读时长 ≈ 39 分钟

Direct3D初始化

预备知识

组件对象模型

组件对象模型（Component Object Model,COM）:不受DirectX语言束缚，并且向后兼容的技术

获得COM接口需要借助特定函数，而不是C++的new
删除COM有Release方法，而不是delete
Mirrosoft::WRL::ComPtr类是Window是下的COM对象的智能指针
当ComPtr出作用域时，它会自动调用Release方法

//Get: 返回一个指向此底层COM接口的指针，此方法常用于把原始COM接口指针作为参数传给函数
ComPtr<ID3D12RootSignature> mRootSignature;
...
    //SetGraphicsRootSignature需要获取ID3D12RootSignature*类型的参数
    mCommandList->SetGraphicsRootSignature(mRootSignature.Get());

//GetAddressOf:返回指向此底层COM接口指针的地址，此函数可以利用函数参数返回COM接口的指针
ComPtr<ID3D12CommandAlllocator> mDirectCmdListAlloc;
...
    ThrowIfFailed(md3dDevice->CreateCommandAllocator(
        D3D12_COMMAND_LIST_TYPE_DIRECT,
    mDirectCmdListAlloc.GetAddressOf());

1	//Reset:将此ComPtr实例设置为nullptr释放与之相关的所有引用，同时减少COM接口引用次数，此方法功能与将ComPtr目标实例赋值nullptr效果相同

纹理格式

2D纹理是一种由数据元素构成的矩阵，每个元素存储的都是一个像素的颜色

DXGI_FORMAT_R32G32B32_FLOAT:每个元素由2个32位无符号整数分量构成，存储的不一定是颜色信息
DXGI_FORMAT_R16G16B16A16_UNORM:每个元素由4个8位无符号分量构成，每个分量都被映射到**[0，1]**的区间
DXGI_FORMAT_R32G32_UINT:每个元素由2个32位无符号整数分量构成
DXGI_FORMAT_R8G8B8A8_UNORM:每个元素由4个8位无符号分量构成，每个分量都被映射到**[0，1]**的区间
DXGI_FORMAT_R8G8B8A8_SNORM:每个元素由4个8位无符号分量构成，每个分量都被映射到**[-1，1]**的区间
DXGI_FORMAT_R9G9B9A9_SINT:每个元素由4个8位无符号分量构成，每个分量都被映射到**[-128，127]**的区间
DXGI_FORMAT_R8G8B8A8_UINT:每个元素由4个8位无符号分量构成，每个分量都被映射到**[0，255]**的区间

其他格式

DXGI_FORMAT_R16G16B16A16_TYPELESS:每个元素由4个16位无符号分量构成，但是没有指出数据类型

交换链和页面翻转

前台缓冲区和后台缓冲区在绘制渲染过程中互换，这种操作称为：呈现（presenting，亦有译作提交、显示）
前后台缓冲区构成了交换链，Direct3D中用==IDXGISwapChain==接口来表示
这个接口不仅储存了前后台缓冲区的纹理，还提供了修改缓冲区大小(IDXGISwapChain::ResiezeBuffers)和呈现缓冲区内容(IDXGISwapChain::Present)的方法
使用2个缓冲区的情况称为双缓冲(double buffering,亦有译作双重缓冲、双倍缓冲等)
还可以用更多的缓冲区，使用3个缓冲区就叫作三重缓冲（triple buffering）

深度缓冲

深度缓冲区（depth buffer）：存储的非图像数据，而是特定像素的深度信息

深度值范围 0.0-1.0
0.0代表观察者在视锥体（视域体、视景体、视截体、视体），即观察者能看到的空间范围
1.0代表观察者在视锥体中嫩通过看到的离自己最远的像素
如果后台缓冲区的分辨率位1280x1024,那么深度缓冲去也应当由1280x1024

深度缓冲区的原理：计算每个像素的深度值，并执行深度测试（depth test），具有最小深度值的像素会最终写入后台缓冲

深度缓冲区也是一种纹理，用如下格式来创建

DXGI_FORMAT_D32_FLOAT_S8X24_UINT:占用64位，取其中的32位指定一个浮点型深度缓冲区，另有8位无符号整数分配给模板缓冲区(stencil buffer),并且将该元素映射到[0,255]
DXGI_FORMAT_D32_FLOAT:指定一个32位浮点型深度缓冲区
DXGI_FORMAT_D24_UNORM_指定一个无符号的24位深度缓冲区，并将该元素映射到[0,1]区间；另有8位无符号整数分配给模板缓冲区(stencil buffer),并且将该元素映射到[0,255]
DXGI_FORMAT_D16_UNORM:指定一个16位浮点型深度缓冲区，并将该元素映射到[0,1]区间

资源与描述符

资源->中间层（即描述符）->GPU

描述符

一种把送往GPU的资源进行描述的轻量级结构；
绘制所需的资源通过描述符绑定到渲染流水线上；
为GPU解释资源，如告知Direct3D某个资源如何使用（绑定到流水线的哪个阶段）；
指定欲绑定资源中的局部数据

常见描述符

CBV/SRV/UAV ：分表表示常量缓冲区(constant buffer view)、着色器资源视图(shader resource view)和无序访问试图(unordered access view)3种资源；
***采样器(sampler，亦有译作取样器)***：表示采样器资源（用于纹理）
RTV:渲染目标视图资源(render target view)
DSV：深度/模板视图资源(depth/stencil view)

描述符堆：存放某种特定类描述符的内存，可以看作是描述符数组

多重采样

超级采样（SSAA）

超级采样：反走样技术

使用4倍于屏幕分辨率大小的后台缓冲区和深度缓冲去；
3D场景以这种更大的分辨率渲染到后台缓冲区中；
当数据要从后台缓冲区调往屏幕显示的时候，会将后台缓冲区按4个像素一组进行解析（降采样,downsample），把放大的采样点数降低回原来采样点数每组用求平均值的方法得到相对平滑的像素颜色
实际上是通过软件的方式提升了画面分辨率
超级采样是高开销的操作，因为限速处理数量和占用内存大小都增加到了4倍，因此Direct3D支持一种性能和效果折中的反走样技术：多重采样(multisampling),记作MSAA

多重采样（MSAA）

多重采样不需要对每个子像素都进行计算
而是仅计算一次像素中心的颜色，在基于可视性和覆盖性将得到的颜色信息分享给其子像素

区别

超级采样：图像颜色要根据每一个像素来计算，因此每个子像素都可以各具不的颜色；开销更大但是更精确
多重采样：每个像素只需要计算一次，最后假尼姑得到的颜色数据复制到多边形覆盖的所有可见子像素中

用Direct3D进行多重采样

typedef struct DXGI_SAMPLE_DESC
{
    UINT count;//指定了每个像素的采样次数，采样次数越多，代价越高
    UINT Quality;;//指示用户期望的图像质量级别，不同厂家而言，这个参数相差很多
}

根据给定的纹理格式和采样数量，用ID3D12Device::CheckFeatureSupport方法查询对应的质量级别

考虑到多重采样会占用内存资源，又为了保证程序性能等原因，通常会把采样数量设定位 4 或 8
如果不希望使用多重采样，可以设置采样数量位1，质量设置为0

功能级别

Direct3D 11开始引用了功能级别(feature level),代码里用 D3D_FEATURE_LEVEL表示

enum D3D_FEATURE_LEVEL
{
    D3D_FEATURE_LEVEL_9_1 = 0x9100,
    D3D_FEATURE_LEVEL_9_2 = 0x9200,
    D3D_FEATURE_LEVEL_9_3 = 0x9300,
    D3D_FEATURE_LEVEL_10_0 = 0xa000,
    D3D_FEATURE_LEVEL_10_1 = 0xa100,
    D3D_FEATURE_LEVEL_11_0 = 0xb000,
    D3D_FEATURE_LEVEL_11_1 = 0xb100
}

功能级别为不同级别所支持的功能进行严格界定

DirectX图形学基础结构

DirectX图形学基础结构(DXGI)是一种与Direct3D配合使用的API

如，IDXGIFactory是DXGI中的关键接口之一，用于创建IDXGISwapChain接口以及枚举显示适配器

一个系统可能由数个显示设备，我们称每一台显示设备都是一个显示输出，用IDXGIOutput接口来表示

功能支持的检测

ID3D12Device::CheckFeatureSupport方法是检测当前图形驱动对多重过采样的支持，圆形如下

1	HRESULT ID3D12Device::CheckFeatureSupport(D3D12_FEATURE Feature,void* pFeatureSuportData,UINT FeatureSupportDataSize);

***Feature:***枚举类型D3D12_FEATURE中的成员之一，用于指定我们希望检测的功能支持类型，具体如下
- D2D12_FEATURE_D3D12_OPTIONS:检测当前图形驱动对Direct3D 12各种功能的支持情况
- D3D12_FEATURE_ARCHITECTURE:检测图形适配器中GPU的硬件体系架构特性
- D3D12_FEATURE_FEATURE_LEVELS:检测对功能级别的支持情况
- D3D12_FEATURE_FORMAT_SUPPORT:检测对给定纹理格式的支持情况
- D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS:检测对多重采样功能的支持情况
pFeatureSuportData：指向某种数据结构的指针，该结构中存有检索到的特定功能支持的信息，此结构体的具体类型取决于Feature参数
- D3D12_FEATURE_D3D12_OPTIONS:返回一个D3D12_FEATURE_DATA_D3D12_OPTIONS实例
- D3D12_FEATURE_ARCHITECTURE:返回D3D12_FEATURE_ARCHITECTURE实例
- D3D12_FEATURE_FEATURE_LEVELS:同上类推
- D3D12_FEATURE_FORMAT_SUPPORT：同上类推
- D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS：同上类推
FeatureSupportDataSize：传回pFeatureSuportData参数中的数据结构大小

资源驻留

Direct3D12中，应用程序通过控制资源在显存中的去留，主动管理资源的驻留情况（Direct3D11中则有系统自动管理）

一般情况，资源创建时就会驻留在显存中，被销毁时则清出。但是通过下面方法我们可以自己管理资源的驻留

1 2	HRESULT ID3D12Device::MakeResident(UINT NumObjects,ID3D12Pageable* const ppObjects); HRESULT ID3D12Device::Evict(UINT NumObjects,ID3D12Pageable const *ppObjects);

这两个方法的第二个参数都是ID3D12Pageable资源数组，第一个参数表示该数组资源的数量

CPU和GPU的交互

每个GPU都至少维护这一个命令队列(command queue，本质上是环形缓冲区，即ring buffer)。
借助Direct3D API，CPU可以用命令列表(command list)将命令提交到这个队列中去
新加入的命令不会立即执行
假如命令列表空空如也，那么GPU会闲置
假如命令列表填满，那么CPU会在某个时刻保持空闲

在Direct3D 12中，命令队列被抽象为==ID3D12CommandQueue==接口来表示，通过填写D3D12_COMMAND_QUEUE_DESC结构体来表示队列，在通过调用ID3D12Device::CreateCommandQueue方法来创建。

命令队列

创建命令队列

//创建队列智能指针
Microsoft::WRL::ComPtr<ID3D12CommandQueue> mCommandQueue;
...;

D3D12_COMMAND_QUEUE_DESC queueDesc = {};
queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
//创建队列方法
 //IID_PPV_ARGS辅助宏本质是将ppType强制转换为void**类型
//Direct3D 12中创建接口实例的API时，大多数都有一个参数是类型void**的待创接口COM ID
ThrowIfFailed(md3dDevice>CreateCommandQueue(&queueDesc,IID_PPV_ARGS(&mCommandQueue))); 

...;
//添加命令到命令列表里
//第一个参数是待执行的命令列表数组的数量
//第二个参数是待执行的命令列表数组
 mCommandQueue->ExecuteCommandLists(_countof(cmdsLists), cmdsLists);
//下列两个方法不是执行命令，而是将命令添加到命令列表里，还是需要通过ExecuteCommandLists方法才将命令真正加入到命令列表
 mCommandQueue->DrawIndexedInstanced(36,1,0,0,0);
 mCommandQueue->RSSetViewports(1,&mScreenViewport);



//结束记录命令
//必须在调用ExecuteCommandLists方法之前先关闭
 mCommandQueue->Close();

内存分配器

内存分配器：存储命令列表里的命令，执行ID3D12CommandQueue::ExecuteCommandLists方法时，命令队列就会引用分配器里的命令

virtual HRESULT STDMETHODCALLTYPE CreateCommandAllocator( 
            _In_  D3D12_COMMAND_LIST_TYPE type,
            REFIID riid,
            _COM_Outptr_  void **ppCommandAllocator) = 0;

type:命令列表类型
- D3D12_COMMAND_LIST_TYPE_DIRECT:GPU可直接执行的命令
- D3D12_COMMAND_LIST_TYPE_BUNDLE:打包的命令列表，一般不用
riid：适配接口的COM ID
ppCommandAllocator:输出指向所建命令分配器的指针

//内存管理指针
Microsoft::WRL::ComPtr<ID3D12CommandAllocator> mDirectCmdListAlloc;
...;

//第一个参数：此命令分配器相关联的命令列表类型，具体见下图
//第二个参数：内存分配器地址
ThrowIfFailed(md3dDevice->CreateCommandAllocator(
		D3D12_COMMAND_LIST_TYPE_DIRECT,
		IID_PPV_ARGS(mDirectCmdListAlloc.GetAddressOf())));

创建命令列表

//原型
virtual HRESULT STDMETHODCALLTYPE CreateCommandList( 
            _In_  UINT nodeMask,
            _In_  D3D12_COMMAND_LIST_TYPE type,
            _In_  ID3D12CommandAllocator *pCommandAllocator,
            _In_opt_  ID3D12PipelineState *pInitialState,
            REFIID riid,
            _COM_Outptr_  void **ppCommandList) = 0;


//实例
ThrowIfFailed(md3dDevice->CreateCommandList(
		0,
		D3D12_COMMAND_LIST_TYPE_DIRECT,
		mDirectCmdListAlloc.Get(), // Associated command allocator
		nullptr,                   // Initial PipelineStateObject
		IID_PPV_ARGS(mCommandList.GetAddressOf())));

nodeMask:如果只有1个GPU，设置成0；多个GPU用于关联的物理GPU
type:命令列表类型
pCommandAllocator:所建命令列表关联的命令分配器，类型必须匹配
pInitialState:指定命令列表的渲染流水线初始状态，一般可以设置为nullptr
riid:待创建的ID3D12CommandList接口的COM ID
ppCommandList:输出指向所建命令列表的指针

小结

可以创建多个关联同一个命令分配器的命令列表
但是不能同时用他们记录命令
其中一个命令列表在记录命令时，必须关闭同一分配器的其他命令列表
要保证命令列表中的所有命令都会按顺序连续的添加到命令分配器内
当创建或重置一个命令列表时，它会处于“打开 ”状态，所以同时为同一命令列表分配器创建两个命令列表会报错

ID3D12CommandQueue::ExecuteCommandList(C)；//把命令添加到命令列表
    /*将命令列表恢复到初始状态，借此继续复用其底层内存；
    重置列表不会影响命令队列的命令，内存分配器在当中维护
    */
    ID3D12GraphicsCommandLIst::Reset();

//GPU提交了一整帧的渲染命令后，我们可能还要为了绘制下一帧服用命令分配器的内存
//注意：在没有确定GPU执行完命令分配器的所有命令之前，千万不要重置命令分配器
ID3D12CommandAllocator::Reset();

GPU与CPU的同步

刷新命令队列：CPU会等待GPU完成所有命令处理，直到到达指定的***围栏点(fence point)***为止。

创建围栏

HRESULT ID3D12Device::CreateFence(UINT64 InitialValue,
                                  D3D12_FENSE_FLAGS Flags,
                                 REFIID riid,
                                 void** ppFence);
//示例
 Microsoft::WRL::ComPtr<ID3D12Fence> mFence;
ThrowIfFailed(md3dDevice->CreateFence(0, D3D12_FENCE_FLAG_NONE,
		IID_PPV_ARGS(&mFence)));

void D3DApp::FlushCommandQueue()
{
	// 增加围栏值，接下来将命令标记到此围栏点
    mCurrentFence++;

    // 向命令队列添加一条用来设置新围栏点的命令
    //由于这条命令有交给GPU处理，所以在GPU处理完命令队列中此Signal()的所有命令之前
    //它不会设置新的围栏点
    ThrowIfFailed(mCommandQueue->Signal(mFence.Get(), mCurrentFence));

	// 在CPU等待GPU，直到后者执行完这个围栏点之前的所有命令
    if(mFence->GetCompletedValue() < mCurrentFence)
	{
		HANDLE eventHandle = CreateEventEx(nullptr, false, false, EVENT_ALL_ACCESS);

        // 若GPU命令中当前的围栏点（即执行到Signal()指令，修改了围栏点），则激发预定事件 
        ThrowIfFailed(mFence->SetEventOnCompletion(mCurrentFence, eventHandle));

        // 等待GPU命中围栏，激发事件
		WaitForSingleObject(eventHandle, INFINITE);
        CloseHandle(eventHandle);
	}
}

资源转换

资源冒险：当GPU的写操作还没有完成或者还没有开始，却开始读取资源的情况

为了解决资源冒险问题，Direct3D设计了一组相关状态，如资源在创建的时候会初一默认状态，直到应用程序通过方法将其转换为另一种状态。

转换资源屏障(transition resource barrier):通过一个API调用来转换多个资源要用到的数组

初始化Direct3D

初始化流程

用D3D12CreateDevice函数创建ID3D12Device接口实例
创建一个ID3D12Fence对象，并且查询描述符的大小
检测用户设备对4X MSAA质量级别的支持情况
一次创建命令队列、命令列表分配器和主命令列表
描述并创建交换链
创建应用程序所需的描述符堆
调整后台缓冲区的大小，并为它创建渲染图标视图
创建深度/模板缓冲区及与之关联的深度/模板视图
设置视口(viewport)和裁剪矩形(scissor rectangle)

创建设备

HRESULT WINAPI D3D12CreateDevice(
    _In_opt_ IUnknown* pAdapter,
    D3D_FEATURE_LEVEL MinimumFeatureLevel,
    _In_ REFIID riid, // Expected: ID3D12Device
    _COM_Outptr_opt_ void** ppDevice );

案例

// Try to create hardware device.
HRESULT hardwareResult = D3D12CreateDevice(
	nullptr,             // default adapter
	D3D_FEATURE_LEVEL_11_0,
	IID_PPV_ARGS(&md3dDevice));

pAdapter:使用的显示适配器，如果空，则使用主显示适配器
MinimumFeatureLevele:应用程序需要硬件所支持的最低功能级别，如果适配器不支持此功能级别，则设备创建失败
riid:ID3D12Device接口的COM ID
ppDevice:返回创建的Direct3D 12设备

创建失败的话会尝试创建WARP设备

创建围栏

ThrowIfFailed(md3dDevice->CreateFence(0, D3D12_FENCE_FLAG_NONE,
		IID_PPV_ARGS(&mFence)));
//查询并保存描述符信息，方便后面使用
	mRtvDescriptorSize = md3dDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
	mDsvDescriptorSize = md3dDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_DSV);
	mCbvSrvUavDescriptorSize = md3dDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);

检测4X MSAA支持

 // Check 4X MSAA quality support for our back buffer format.
   // All Direct3D 11 capable devices support 4X MSAA for all render 
   // target formats, so we only need to check quality support.

D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS msQualityLevels;
msQualityLevels.Format = mBackBufferFormat;
msQualityLevels.SampleCount = 4;
msQualityLevels.Flags = D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE;
msQualityLevels.NumQualityLevels = 0;
ThrowIfFailed(md3dDevice->CheckFeatureSupport(
	D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS,
	&msQualityLevels,
	sizeof(msQualityLevels)));

   m4xMsaaQuality = msQualityLevels.NumQualityLevels;
assert(m4xMsaaQuality > 0 && "Unexpected MSAA quality level.");

创建命令队列和命令列表

命令队列：ID3D12CommandQueue
命令分配器：ID3D12CommandAllocator
命令列表：ID3D12GraphicsCommandList

//.h申明
Microsoft::WRL::ComPtr<ID3D12CommandQueue> mCommandQueue;
    Microsoft::WRL::ComPtr<ID3D12CommandAllocator> mDirectCmdListAlloc;
    Microsoft::WRL::ComPtr<ID3D12GraphicsCommandList> mCommandList;
//.cpp
void D3DApp::CreateCommandObjects()
{
	D3D12_COMMAND_QUEUE_DESC queueDesc = {};
	queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
	queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
	ThrowIfFailed(md3dDevice->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&mCommandQueue)));

	ThrowIfFailed(md3dDevice->CreateCommandAllocator(
		D3D12_COMMAND_LIST_TYPE_DIRECT,
		IID_PPV_ARGS(mDirectCmdListAlloc.GetAddressOf())));

	ThrowIfFailed(md3dDevice->CreateCommandList(
		0,
		D3D12_COMMAND_LIST_TYPE_DIRECT,
		mDirectCmdListAlloc.Get(), // 关联的命令分配器
		nullptr,                   //初始的PipelineStateObject
		IID_PPV_ARGS(mCommandList.GetAddressOf())));

//从关闭状态开始。 这是因为我们第一次提到
//在命令列表中，我们将对其进行重置，并且需要先关闭它
//调用Reset。
	mCommandList->Close();
}

创建交换链

DXGI_SWAP_CHAIN_DESC结构体定义

typedef struct DXGI_SWAP_CHAIN_DESC
    {
    DXGI_MODE_DESC BufferDesc;
    DXGI_SAMPLE_DESC SampleDesc;
    DXGI_USAGE BufferUsage;
    UINT BufferCount;
    HWND OutputWindow;
    BOOL Windowed;
    DXGI_SWAP_EFFECT SwapEffect;
    UINT Flags;
    } 	DXGI_SWAP_CHAIN_DESC;

BufferDesc:后台缓冲区的属性，主要是高度、宽度和像素格式
SampleDesc：多重采样的质量级别以及对每个像素的采样次数
BufferUsage：如果要将数据渲染到后台缓冲区，则设置为DXGI_USAGE_RENDER_TARGET_OUTPUT
BufferCount:缓冲区数量，指定为2即双缓冲
OutputWindow：渲染窗口的句柄
Windowed：true则窗口模式运行，否则全屏
SwapEffect：指定为DXGI_SWAP_EFFECT_FLIP_DISCARD
Flags：可选；如果指定为DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH则程序切换为全屏时，将选择适用于当前窗口尺寸的显示模式；否则就采用当前桌面的显示模式

DXGI_MODE_DESC

typedef struct DXGI_MODE_DESC
{
    UINT Width;//缓冲区分辨率的宽度
    UINT Height;//高度
    DXGI_RATIONAL RefreshRate;
    DXGI_FORMAT Format;//显示格式
    DXGI_MODE_SCANLINE_ORDER ScanlineOrdering;//逐行扫面vs.隔行扫描
    DXGI_MODE_SCALING Scaling;//如何进行拉升
} DXGI_MODE_DESC;

执行创建交换链

void D3DApp::CreateSwapChain()
{
    // 释放我们将重新创建的先前的交换链。
    mSwapChain.Reset();

    DXGI_SWAP_CHAIN_DESC sd;
    sd.BufferDesc.Width = mClientWidth;
    sd.BufferDesc.Height = mClientHeight;
    sd.BufferDesc.RefreshRate.Numerator = 60;
    sd.BufferDesc.RefreshRate.Denominator = 1;
    sd.BufferDesc.Format = mBackBufferFormat;
    sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
    sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
    sd.SampleDesc.Count = m4xMsaaState ? 4 : 1;
    sd.SampleDesc.Quality = m4xMsaaState ? (m4xMsaaQuality - 1) : 0;
    sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    sd.BufferCount = SwapChainBufferCount;
    sd.OutputWindow = mhMainWnd;
    sd.Windowed = true;
	sd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
    sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;

	// Note: 交换链使用队列执行刷新。
    ThrowIfFailed(mdxgiFactory->CreateSwapChain(
		mCommandQueue.Get(),
		&sd, 
		mSwapChain.GetAddressOf()));
}

创建描述符堆

创建描述符堆来存储程序中要用到的描述符/视图，本例中需要创建两个描述符堆来存储SwapChainBufferCount个RTV ,另外一个存储1个DSV

//.h
	Microsoft::WRL::ComPtr<ID3D12DescriptorHeap> mRtvHeap;
    Microsoft::WRL::ComPtr<ID3D12DescriptorHeap> mDsvHeap;
//.cpp
void D3DApp::CreateRtvAndDsvDescriptorHeaps()
{
    D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc;
    rtvHeapDesc.NumDescriptors = SwapChainBufferCount;//static value=2
    rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
    rtvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
	rtvHeapDesc.NodeMask = 0;
    ThrowIfFailed(md3dDevice->CreateDescriptorHeap(
        &rtvHeapDesc, IID_PPV_ARGS(mRtvHeap.GetAddressOf())));


    D3D12_DESCRIPTOR_HEAP_DESC dsvHeapDesc;
    dsvHeapDesc.NumDescriptors = 1;
    dsvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV;
    dsvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
	dsvHeapDesc.NodeMask = 0;
    ThrowIfFailed(md3dDevice->CreateDescriptorHeap(
        &dsvHeapDesc, IID_PPV_ARGS(mDsvHeap.GetAddressOf())));
}

创建以后需要通过方法来获得描述符的句柄

D3D12_CPU_DESCRIPTOR_HANDLE D3DApp::CurrentBackBufferView()const
{//构造函数根据给定的偏移量找到当前后台缓冲区的RTV
	return CD3DX12_CPU_DESCRIPTOR_HANDLE(
		mRtvHeap->GetCPUDescriptorHandleForHeapStart(),//堆中的首个句柄
		mCurrBackBuffer,//偏移至后台缓冲区描述符句柄的索引
		mRtvDescriptorSize);//描述符所占字节大小
}

D3D12_CPU_DESCRIPTOR_HANDLE D3DApp::DepthStencilView()const
{
	return mDsvHeap->GetCPUDescriptorHandleForHeapStart();
}

创建渲染目标视图

资源不能与渲染流水线中的阶段直接绑定，所以必须先为资源创建视图（描述符），并将其绑定到流水线阶段

virtual HRESULT STDMETHODCALLTYPE GetBuffer( 
           /* [in] */ UINT Buffer,
           /* [annotation][in] */ 
           _In_  REFIID riid,
           /* [annotation][out][in] */ 
           _COM_Outptr_  void **ppSurface) = 0;

Buffer:后台缓冲区索引
riid:COM ID
ppSurface:返回ID3D12Resource接口的指针，即后台缓冲区

调用此方法后会增加计数，所以使用后需要释放，需通过ComPtr

然后获得后台缓冲区创建的渲染目标视图

virtual void STDMETHODCALLTYPE CreateRenderTargetView( 
           _In_opt_  ID3D12Resource *pResource,
           _In_opt_  const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
           _In_  D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0;

pResource:指定用作渲染目标的资源
pDesc:指向D3D12_RENDER_TARGET_VIEW_DESC数组结构体的指针
DestDescriptor:引用所创建渲染目标视图的描述符句柄

CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHeapHandle(mRtvHeap->GetCPUDescriptorHandleForHeapStart());
	for (UINT i = 0; i < SwapChainBufferCount; i++)
	{
        //获得交换链中的第 i 个缓冲区
		ThrowIfFailed(mSwapChain->GetBuffer(i, IID_PPV_ARGS(&mSwapChainBuffer[i])));
        //为此缓冲区创建一个RTV
		md3dDevice->CreateRenderTargetView(mSwapChainBuffer[i].Get(), nullptr, rtvHeapHandle);
        //偏移到下一个缓冲区
		rtvHeapHandle.Offset(1, mRtvDescriptorSize);
	}

创建深度/模板缓冲区及其视图

因为深度缓冲区就是一种2D纹理，所以我们通过填写D3D12_RESOURCE_DESC结构体来描述纹理资源

再用ID3D12Device::CreateCommittedResource方法来创建它

D3D12_RESOURCE_DESC

typedef struct D3D12_RESOURCE_DESC
    {
    D3D12_RESOURCE_DIMENSION Dimension;
    UINT64 Alignment;
    UINT64 Width;
    UINT Height;
    UINT16 DepthOrArraySize;
    UINT16 MipLevels;
    DXGI_FORMAT Format;
    DXGI_SAMPLE_DESC SampleDesc;
    D3D12_TEXTURE_LAYOUT Layout;
    D3D12_RESOURCE_FLAGS Flags;
    } 	D3D12_RESOURCE_DESC;

D3D12_RESOURCE_DIMENSION Dimension：资源的维度

```cpp
enum D3D12_RESOURCE_DIMENSION

{
    D3D12_RESOURCE_DIMENSION_UNKNOWN    = 0,
    D3D12_RESOURCE_DIMENSION_BUFFER    = 1,
    D3D12_RESOURCE_DIMENSION_TEXTURE1D    = 2,
    D3D12_RESOURCE_DIMENSION_TEXTURE2D    = 3,
    D3D12_RESOURCE_DIMENSION_TEXTURE3D    = 4
}     D3D12_RESOURCE_DIMENSION;


2. Width:像素单位的纹理宽度。对于缓冲区，此项是占用的字节数

3. Height:同上

4. DepthOrArraySize:纹素为单位的纹理深度，或者是纹理数组的大小

5. MipLevels：mipmap层级的数量

6. Format:DXGI_FORMAT枚举成员之一

7. SampleDesc：多重采样级别和每个像素的采样次数

8. Layout：D3D12_TEXTURE_LAYOUT枚举成员之一，用于指定纹理布局

9. Flags：杂项标记，对于深度/模板缓冲区资源，设置为`D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL`



> `GPU`资源都存储在`堆`中，本质是具有特定属性的`GPU`显存快
>
> `ID3D12Device::CreateCommitedResource`方法根据提供的属性创建一个资源和一个堆，把资源提交到这个堆



###### CreateCommittedResource

```cpp
virtual HRESULT STDMETHODCALLTYPE CreateCommittedResource( 
            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,//资源提交到的堆的属性，见下
            D3D12_HEAP_FLAGS HeapFlags,//额外标记，一般是D3D12_HEAP_FLAG_NONE
            _In_  const D3D12_RESOURCE_DESC *pDesc,//描述待创建的资源
            D3D12_RESOURCE_STATES InitialResourceState,//此参数来设置资源的初始状态
            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,//清楚资源的优化值，不需要就选择nullptr
            REFIID riidResource,//COM ID
            _COM_Outptr_opt_  void **ppvResource) = 0;//新创建的资源，指向ID3D12Resource的指针

D3D12_HEAP_PROPERTIES

typedef struct D3D12_HEAP_PROPERTIES
    {
    D3D12_HEAP_TYPE Type;
    D3D12_CPU_PAGE_PROPERTY CPUPageProperty;
    D3D12_MEMORY_POOL MemoryPoolPreference;
    UINT CreationNodeMask;
    UINT VisibleNodeMask;
    } 	D3D12_HEAP_PROPERTIES;

D3D12_HEAP_TYPE

enum D3D12_HEAP_TYPE
    {
        D3D12_HEAP_TYPE_DEFAULT	= 1,//默认堆
        D3D12_HEAP_TYPE_UPLOAD	= 2,//上传堆
        D3D12_HEAP_TYPE_READBACK	= 3,//回读堆
        D3D12_HEAP_TYPE_CUSTOM	= 4//高级场景使用
    } 	D3D12_HEAP_TYPE;

示例

 // Create the depth/stencil buffer and view.
  D3D12_RESOURCE_DESC depthStencilDesc;
  depthStencilDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
  depthStencilDesc.Alignment = 0;
  depthStencilDesc.Width = mClientWidth;
  depthStencilDesc.Height = mClientHeight;
  depthStencilDesc.DepthOrArraySize = 1;
  depthStencilDesc.MipLevels = 1;
  depthStencilDesc.Format = mDepthStencilFormat;
  depthStencilDesc.SampleDesc.Count = m4xMsaaState ? 4 : 1;
  depthStencilDesc.SampleDesc.Quality = m4xMsaaState ? (m4xMsaaQuality - 1) : 0;
  depthStencilDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
  depthStencilDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;

  D3D12_CLEAR_VALUE optClear;
  optClear.Format = mDepthStencilFormat;
  optClear.DepthStencil.Depth = 1.0f;
  optClear.DepthStencil.Stencil = 0;
  ThrowIfFailed(md3dDevice->CreateCommittedResource(
      &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT),
D3D12_HEAP_FLAG_NONE,
      &depthStencilDesc,
D3D12_RESOURCE_STATE_COMMON,
      &optClear,
      IID_PPV_ARGS(mDepthStencilBuffer.GetAddressOf())));

 // 使用资源格式将描述符创建为整个资源的MIP级别0。
   md3dDevice->CreateDepthStencilView(mDepthStencilBuffer.Get(), nullptr, DepthStencilView());

   // 将资源从其初始状态转换为深度缓冲区。
mCommandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(mDepthStencilBuffer.Get(),
	D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_DEPTH_WRITE));

设置视口

1	D3D12_VIEWPORT mScreenViewport;

typedef struct D3D12_VIEWPORT
    {
    FLOAT TopLeftX;
    FLOAT TopLeftY;
    FLOAT Width;
    FLOAT Height;
    FLOAT MinDepth;//负责从区间0-1转化为MinDepth-MaxDepth
    FLOAT MaxDepth;
    } 	D3D12_VIEWPORT;

填好结构体以后通过函数ID3D12GraphicsCommandList::RSSetViewports方法来设置视口

示例

mScreenViewport.TopLeftX = 0;
	mScreenViewport.TopLeftY = 0;
	mScreenViewport.Width    = static_cast<float>(mClientWidth);
	mScreenViewport.Height   = static_cast<float>(mClientHeight);
	mScreenViewport.MinDepth = 0.0f;
	mScreenViewport.MaxDepth = 1.0f;


 mCommandList->RSSetViewports(1, &mScreenViewport);

不能为同一个渲染目标指定多个视口

而多个视口则是一种用于对多个渲染目标同时进行渲染的高级技术

命令列表重置，视口也要重置

设置裁剪矩形

typedef struct tagRECT
{
    LONG    left;
    LONG    top;
    LONG    right;
    LONG    bottom;
} RECT, *PRECT, NEAR *NPRECT, FAR *LPRECT;

1
2
3

mScissorRect = { 0, 0, mClientWidth, mClientHeight };

mCommandList->RSSetScissorRects(1, &mScissorRect);

不能为同一个渲染目标指定多个裁剪矩形。

多裁剪矩形是以各种用于同时对多个渲染目标进行渲染的高级技术

裁剪矩形需要随着命令列表重置而重置

计时与动画

性能计时器

QueryPerformanceCounter函数来活得性能计时器测量的当前时刻值

1
2
3

__int64 countsPerSec;
	QueryPerformanceFrequency((LARGE_INTEGER*)&countsPerSec);
	mSecondsPerCount = 1.0 / (double)countsPerSec;

通过如下方式转换为秒

1	valueInSecs=valueInCounts * mSecondsPercount;

调用2次QueryPerformanceCounter函数得到两个时间戳的相对插值

__int64 A;
	QueryPerformanceFrequency((LARGE_INTEGER*)&A);
__int64 B;
	QueryPerformanceFrequency((LARGE_INTEGER*)&B);

B-A即可获得执行期间的计数值，或者(B-1)*mSecondsPerCount获得代码运行期间所花费的秒数

游戏计时器类

class GameTimer
{
public:
	GameTimer();

	float TotalTime()const; //秒为单位
	float DeltaTime()const; //秒为单位

	void Reset(); // 开始循环之前调用
	void Start(); // 接触计时器暂停时调用
	void Stop();  // 暂停计时器调用
	void Tick();  //每帧都要调用

private:
	double mSecondsPerCount;
	double mDeltaTime;

	__int64 mBaseTime;
	__int64 mPausedTime;
	__int64 mStopTime;
	__int64 mPrevTime;
	__int64 mCurrTime;

	bool mStopped;
};

帧与帧之间的时间间隔

void GameTimer::Tick()
{
	if( mStopped )
	{
		mDeltaTime = 0.0;
		return;
	}
	// 获得本帧开始的时刻
	__int64 currTime;
	QueryPerformanceCounter((LARGE_INTEGER*)&currTime);
	mCurrTime = currTime;

	// 两帧的时间差
	mDeltaTime = (mCurrTime - mPrevTime)*mSecondsPerCount;

	// 把当前时间设置为下一次的开始时间
	mPrevTime = mCurrTime;

	//保证时间差为非负值；
    //在处理器处于节能模式或者计算两次时间差的过程中切换到了另一个处理器可能会得到负值
	if(mDeltaTime < 0.0)
	{
		mDeltaTime = 0.0;
	}
}

次Tick函数被调用在D3DApp::Run函数

int D3DApp::Run()
{
	MSG msg = {0};
 
	mTimer.Reset();

	while(msg.message != WM_QUIT)
	{
		// If there are Window messages then process them.
		if(PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
		{
            TranslateMessage( &msg );
            DispatchMessage( &msg );
		}
		// Otherwise, do animation/game stuff.
		else
        {	
			mTimer.Tick();

			if( !mAppPaused )
			{
				CalculateFrameStats();
				Update(mTimer);	
                Draw(mTimer);
			}
			else
			{
				Sleep(100);
			}
        }
    }

	return (int)msg.wParam;
}

Reset方法初始化第一帧的数据，因为第一帧没有之前的帧

void GameTimer::Reset()
{
	__int64 currTime;
	QueryPerformanceCounter((LARGE_INTEGER*)&currTime);

	mBaseTime = currTime;
	mPrevTime = currTime;
	mStopTime = 0;
	mStopped  = false;
}

总时间

float GameTimer::TotalTime()const
{


    //如果我们停止了，请勿计算自停止以来经过的时间。
    //此外，如果我们之前已经停顿了一下
    // mStopTime-mBaseTime包含暂停时间，我们不想计算。
    //要纠正此问题，我们可以从mStopTime中减去暂停时间： 
	//
	//                     |<--paused time-->|
	// ----*---------------*-----------------*------------*------------*------> time
	//  mBaseTime       mStopTime        startTime     mStopTime    mCurrTime

	if( mStopped )
	{
		return (float)(((mStopTime - mPausedTime)-mBaseTime)*mSecondsPerCount);
	}

    //距离mCurrTime-mBaseTime包括暂停时间，
    //我们不想计算。 要纠正这一点，我们可以减去
    //从mCurrTime暂停的时间： 
	//
	//  (mCurrTime - mPausedTime) - mBaseTime 
	//
	//                     |<--paused time-->|
	// ----*---------------*-----------------*------------*------> time
	//  mBaseTime       mStopTime        startTime     mCurrTime
	
	else
	{
		return (float)(((mCurrTime-mPausedTime)-mBaseTime)*mSecondsPerCount);
	}
}

应用程序框架示例

自己模仿框架的代码

DXApp.h

#pragma once
#include "../Common/d3dUtil.h"
#include "../Common/d3dx12.h"
#include "../Common/GameTimer.h"

#if defined(DEBUG) || defined(_DEBUG)
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#endif
#include <dxgiformat.h>

// Link necessary d3d12 libraries.
#pragma comment(lib,"d3dcompiler.lib")
#pragma comment(lib, "D3D12.lib")
#pragma comment(lib, "dxgi.lib")




class DXApp
{

public:
	DXApp(HINSTANCE nInstance);
	DXApp(const DXApp& rhs) = delete;
	DXApp& operator=(const DXApp& rhs) = delete;
	virtual ~DXApp();

protected:
	virtual void OnResize();
	virtual bool Initialize();
	virtual void CreateRtvAndDsvDescriptorHeaps();//创建描述符堆
	virtual void Update(const GameTimer& gt) = 0;
	virtual void Draw(const GameTimer& gt) = 0;

	bool InitMainWindow();//初始化窗口
	bool InitDirect3D();//初始化DX


	void FlushCommandQueue();//齐平命令队列
	void CreateSwapChain();//创建交换链
	void CreateCommandObjects();//创建命令队列、命令适配器、命令列表


	ID3D12Resource* CurrentBackBuffer()const;
	D3D12_CPU_DESCRIPTOR_HANDLE CurrentBackBufferView()const;
	D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView()const;


	void LogAdapters();
	void LogAdapterOutputs(IDXGIAdapter* adapter);
	void LogOutputDisplayModes(IDXGIOutput* output, DXGI_FORMAT format);
public:
	static DXApp* GetApp();
	HINSTANCE AppInst()const;//得到应用程序实例
	HWND      MainWnd()const;//得到窗口
	float     AspectRatio()const;//长宽比
	bool Get4xMsaaState()const;//4XMSAA开启与否
	void Set4xMsaaState(bool value);//设置4XMSAA

	int Run();
	void CalculateFrameStats();
	/*
	HWND hwnd; //窗口句柄 
	UINT message; //消息常量标识符 
	WPARAM wParam; //32位消息的特定附加信息,具体表示什么处决于message 
	LPARAM lParam; //32位消息的特定附加信息,具体表示什么处决于message 
	*/
	virtual LRESULT MsgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);

	//鼠标输入
	virtual void OnMouseDown(WPARAM btnState, int x, int y) { }
	virtual void OnMouseUp(WPARAM btnState, int x, int y) { }
	virtual void OnMouseMove(WPARAM btnState, int x, int y) { }



protected:

	static DXApp* mApp;

	HINSTANCE mhAppInst = nullptr; // 应用程序实例句柄
	HWND      mhMainWnd = nullptr; // 主窗口句柄
	bool      mAppPaused = false;  // 应用程序是否已暂停？
	bool      mMinimized = false;  // 将应用程序最小化?
	bool      mMaximized = false;  // 应用程序是否已最大化？
	bool      mResizing = false;   // 是否拖动了大小调整栏？
	bool      mFullscreenState = false;// 启用全屏

	// 是否启用 4X MSAA (?.1.8).  The default is false.
	bool      m4xMsaaState = false;    // 启用 4X MSAA 
	UINT      m4xMsaaQuality = 0;      // 4倍MSAA的质量水平

	GameTimer mTimer;

	//COM
	Microsoft::WRL::ComPtr<ID3D12Device> md3dDevice; //设备接口
	Microsoft::WRL::ComPtr<IDXGIFactory4> mdxgiFactory;
	Microsoft::WRL::ComPtr<IDXGISwapChain> mSwapChain;//交换链

	Microsoft::WRL::ComPtr<ID3D12Fence> mFence;//围栏
	UINT64 mCurrentFence = 0;

	Microsoft::WRL::ComPtr<ID3D12CommandQueue> mCommandQueue;//命令队列
	Microsoft::WRL::ComPtr<ID3D12CommandAllocator> mDirectCmdListAlloc;//适配器
	Microsoft::WRL::ComPtr<ID3D12GraphicsCommandList> mCommandList;//列表
	//描述符
	UINT mRtvDescriptorSize = 0;
	UINT mDsvDescriptorSize = 0;
	UINT mCbvSrvUavDescriptorSize = 0;

	static const int SwapChainBufferCount = 2;//双重缓冲
	int mCurrBackBuffer = 0;
	Microsoft::WRL::ComPtr<ID3D12Resource> mSwapChainBuffer[SwapChainBufferCount];//交换链缓冲区数组
	Microsoft::WRL::ComPtr<ID3D12Resource> mDepthStencilBuffer;//深度模板缓冲区
	
	Microsoft::WRL::ComPtr<ID3D12DescriptorHeap> mRtvHeap;//RTV描述符堆
	Microsoft::WRL::ComPtr<ID3D12DescriptorHeap> mDsvHeap;//DSV描述符堆

	std::wstring mMainWndCaption = L"DX App";
	D3D_DRIVER_TYPE md3dDriverType = D3D_DRIVER_TYPE_HARDWARE;
	DXGI_FORMAT mBackBufferFormat = DXGI_FORMAT_R8G8B8A8_UNORM;
	DXGI_FORMAT mDepthStencilFormat = DXGI_FORMAT_D24_UNORM_S8_UINT;

	D3D12_VIEWPORT mScreenViewport;//视口
	D3D12_RECT mScissorRect;//裁剪

	int mClientWidth = 800;
	int mClientHeight = 600;
};

DXApp.cpp

#include "DXApp.h"
#include "WindowsX.h"
#include <winuser.h>
#include <dxgi.h>
#include <iostream>

using Microsoft::WRL::ComPtr;
using namespace std;
using namespace DirectX;



DXApp* DXApp::mApp = nullptr;

LRESULT CALLBACK
MainWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	//cout << "test";
	return DXApp::GetApp()->MsgProc(hwnd, msg, wParam, lParam);
}



DXApp::DXApp(HINSTANCE nInstance):mhAppInst(nInstance)
{
	assert(mApp == nullptr);
	mApp = this;
}

DXApp::~DXApp()
{
	if (mhAppInst != nullptr)
	{
		FlushCommandQueue();
	}
}

void DXApp::OnResize()
{
	assert(md3dDevice);
	assert(mSwapChain);
	assert(mDirectCmdListAlloc);

	FlushCommandQueue();

	ThrowIfFailed(mCommandList->Reset(mDirectCmdListAlloc.Get(),nullptr));

	//释放我们将重新创建的先前资源。
	for (int i=0;i<SwapChainBufferCount;++i)
	{
		mSwapChainBuffer[i].Reset();
	}
	mDepthStencilBuffer.Reset();


	//调整交换链的大小。
	ThrowIfFailed(mSwapChain->ResizeBuffers(
	SwapChainBufferCount,
	mClientWidth,
	mClientHeight,
	mBackBufferFormat,
	DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH));

	mCurrBackBuffer=0;

	CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHeapHandle(mRtvHeap->GetCPUDescriptorHandleForHeapStart());
	for (UINT i = 0; i < SwapChainBufferCount; i++)
	{
		//构造函数根据给定的偏移量找到当前后台缓冲区的RTV
		ThrowIfFailed(mSwapChain->GetBuffer(i, IID_PPV_ARGS(&mSwapChainBuffer[i])));
		md3dDevice->CreateRenderTargetView(mSwapChainBuffer[i].Get(), nullptr, rtvHeapHandle);//堆中的首个句柄
		rtvHeapHandle.Offset(1, mRtvDescriptorSize);
	}

	//创建深度/模板缓冲区和视口
	D3D12_RESOURCE_DESC depthStencilDesc;
	depthStencilDesc.Dimension= D3D12_RESOURCE_DIMENSION_TEXTURE2D;
	depthStencilDesc.Alignment=0;
	depthStencilDesc.Width=mClientWidth;
	depthStencilDesc.Height=mClientHeight;
	depthStencilDesc.DepthOrArraySize=1;
	depthStencilDesc.MipLevels=1;
	depthStencilDesc.Format=mDepthStencilFormat;
	depthStencilDesc.SampleDesc.Count=m4xMsaaState?4:1;
	depthStencilDesc.SampleDesc.Quality=m4xMsaaState?(m4xMsaaQuality-1):0;
	depthStencilDesc.Layout=D3D12_TEXTURE_LAYOUT_UNKNOWN;
	depthStencilDesc.Flags=D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;

	D3D12_CLEAR_VALUE optClear;
	optClear.Format=mDepthStencilFormat;
	optClear.DepthStencil.Depth=1.0f;
	optClear.DepthStencil.Stencil=0;
	ThrowIfFailed(md3dDevice->CreateCommittedResource(
		&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT),
		D3D12_HEAP_FLAG_NONE,
		&depthStencilDesc,
		D3D12_RESOURCE_STATE_COMMON,
		&optClear,
		IID_PPV_ARGS(mDepthStencilBuffer.GetAddressOf())));

		//使用资源的格式将描述符创建为整个资源的MIP级别0。
	md3dDevice->CreateDepthStencilView(mDepthStencilBuffer.Get(),nullptr, DepthStencilView());
	//将资源从其初始状态转换为深度缓冲区。
	mCommandList->ResourceBarrier(1,&CD3DX12_RESOURCE_BARRIER::Transition(mDepthStencilBuffer.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_DEPTH_WRITE));
	//执行resize命令
	ThrowIfFailed(mCommandList->Close());
	ID3D12CommandList* cmdsLists[]={mCommandList.Get()};
	mCommandQueue->ExecuteCommandLists(_countof(cmdsLists),cmdsLists);

	//等待到resize完成
	FlushCommandQueue();

	//更新视口变换以覆盖客户区域。
	mScreenViewport.TopLeftX = 0;
	mScreenViewport.TopLeftY = 0;
	mScreenViewport.Width = static_cast<float>(mClientWidth);
	mScreenViewport.Height = static_cast<float>(mClientHeight);
	mScreenViewport.MinDepth = 0.0f;
	mScreenViewport.MaxDepth = 1.0f;

	mScissorRect={0,0,mClientWidth,mClientHeight};
}

bool DXApp::Initialize()
{
	if (!InitMainWindow())
	{
		return false;
	}
	if (!InitDirect3D())
	{
		return false;
	}
	OnResize();
	return true;
}

void DXApp::CreateRtvAndDsvDescriptorHeaps()
{
	D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc;
	rtvHeapDesc.NumDescriptors=SwapChainBufferCount;
	rtvHeapDesc.Type=D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
	rtvHeapDesc.Flags=D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
	rtvHeapDesc.NodeMask=0;
	ThrowIfFailed(md3dDevice->CreateDescriptorHeap(&rtvHeapDesc,IID_PPV_ARGS(mRtvHeap.GetAddressOf())));

	D3D12_DESCRIPTOR_HEAP_DESC dsvHeapDesc;
	dsvHeapDesc.NumDescriptors = SwapChainBufferCount;
	dsvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV;
	dsvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
	dsvHeapDesc.NodeMask = 0;
	ThrowIfFailed(md3dDevice->CreateDescriptorHeap(&dsvHeapDesc, IID_PPV_ARGS(mDsvHeap.GetAddressOf())));

}

bool DXApp::InitMainWindow()
{
	WNDCLASS wc;
	wc.style = CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc = MainWndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = mhAppInst;
	wc.hIcon = LoadIcon(0, IDI_APPLICATION);
	wc.hCursor = LoadCursor(0, IDC_ARROW);
	wc.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);
	wc.lpszMenuName = 0;
	wc.lpszClassName = L"MainWnd";

	if (!RegisterClass(&wc))
	{
		MessageBox(0, L"RegisterClass Failed.", 0, 0);
		return false;
	}

	// Compute window rectangle dimensions based on requested client area dimensions.
	RECT R = { 0, 0, mClientWidth, mClientHeight };
	AdjustWindowRect(&R, WS_OVERLAPPEDWINDOW, false);
	int width = R.right - R.left;
	int height = R.bottom - R.top;

	mhMainWnd = CreateWindow(L"MainWnd", mMainWndCaption.c_str(),
		WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, width, height, 0, 0, mhAppInst, 0);
	if (!mhMainWnd)
	{
		MessageBox(0, L"CreateWindow Failed.", 0, 0);
		return false;
	}

	ShowWindow(mhMainWnd, SW_SHOW);
	UpdateWindow(mhMainWnd);

	return true;
}



bool DXApp::InitDirect3D()
{
//	{
//#if defined(DEBUG) || defined(_DEBUG) 
//		// Enable the D3D12 debug layer.
//		{
//			ComPtr<ID3D12Debug> debugController;
//			ThrowIfFailed(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController)));
//			debugController->EnableDebugLayer();
//		}
//#endif
	ThrowIfFailed(CreateDXGIFactory(IID_PPV_ARGS(&mdxgiFactory)));

	//创建硬件设备
	HRESULT hardwareResult = D3D12CreateDevice(nullptr, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&md3dDevice));//第一个参数是空则使用默认显示器
	//回退至WARP设备
	if (FAILED(hardwareResult))
	{
		ComPtr<IDXGIAdapter> pWarpAdapter;
		ThrowIfFailed(mdxgiFactory->EnumWarpAdapter(IID_PPV_ARGS(&pWarpAdapter)));
		ThrowIfFailed(D3D12CreateDevice(pWarpAdapter.Get(), D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&md3dDevice)));
	}
		ThrowIfFailed(md3dDevice->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&mFence)));

		//描述符信息，方便以后使用
		mRtvDescriptorSize = md3dDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
		mDsvDescriptorSize = md3dDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_DSV);
		mCbvSrvUavDescriptorSize = md3dDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);

		//检查4X MSAA质量对我们的后缓冲区格式的支持。
		 //所有支持Direct3D 11的设备都对所有渲染支持4倍MSAA
		 //目标格式，因此我们只需要检查质量支持。
		D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS msQualityLevels;
		msQualityLevels.Format = mBackBufferFormat;
		msQualityLevels.SampleCount = 4;
		msQualityLevels.Flags = D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE;
		msQualityLevels.NumQualityLevels = 0;
		ThrowIfFailed(md3dDevice->CheckFeatureSupport(D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS, &msQualityLevels, sizeof(msQualityLevels)));
		m4xMsaaQuality = msQualityLevels.NumQualityLevels;
		assert(m4xMsaaQuality > 0 && "Unexpected MSAA quality level.");
	

		CreateCommandObjects();
		CreateSwapChain();
		CreateRtvAndDsvDescriptorHeaps();

	return true;
}

void DXApp::FlushCommandQueue()
{
	//提升围栏值以将命令标记到该围栏点。
	mCurrentFence++;
	//将指令添加到命令队列以设置新的防护点。 因为我们
	//在GPU时间轴上，直到GPU完成后才会设置新的围栏点
	//处理此Signal（）之前的所有命令。
	ThrowIfFailed(mCommandQueue->Signal(mFence.Get(),mCurrentFence));

	//等待直到GPU完成命令为止。
	if (mFence->GetCompletedValue() < mCurrentFence)
	{
		HANDLE eventHandle=CreateEventEx(nullptr,false,false,EVENT_ALL_ACCESS);
		//GPU击中当前围墙时触发事件。
		ThrowIfFailed(mFence->SetEventOnCompletion(mCurrentFence,eventHandle));

		//等到GPU击中当前的fence事件后再触发。
		WaitForSingleObject(eventHandle,INFINITE);
		CloseHandle(eventHandle);
	}
}

void DXApp::CreateSwapChain()
{
	mSwapChain.Reset();
	DXGI_SWAP_CHAIN_DESC sd;
	sd.BufferDesc.Width = mClientWidth;
	sd.BufferDesc.Height = mClientHeight;
	sd.BufferDesc.RefreshRate.Numerator = 60;
	sd.BufferDesc.RefreshRate.Denominator = 1;
	sd.BufferDesc.Format = mBackBufferFormat;
	sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
	sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
	sd.SampleDesc.Count = m4xMsaaState ? 4 : 1;
	sd.SampleDesc.Quality = m4xMsaaState ? (m4xMsaaQuality - 1) : 0;
	sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
	sd.BufferCount = SwapChainBufferCount;
	sd.OutputWindow = mhMainWnd;
	sd.Windowed = true;
	sd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
	sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;

	// Note: Swap chain uses queue to perform flush.
	ThrowIfFailed(mdxgiFactory->CreateSwapChain(
		mCommandQueue.Get(),
		&sd,
		mSwapChain.GetAddressOf()));
}

void DXApp::CreateCommandObjects()
{
	D3D12_COMMAND_QUEUE_DESC queueDesc = {};
	queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
	queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
	ThrowIfFailed(md3dDevice->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&mCommandQueue)));
	ThrowIfFailed(md3dDevice->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(mDirectCmdListAlloc.GetAddressOf())));
	ThrowIfFailed(md3dDevice->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, mDirectCmdListAlloc.Get(), nullptr, IID_PPV_ARGS(mCommandList.ReleaseAndGetAddressOf())));

	//从关闭状态开始。 这是因为我们第一次提到
	//在命令列表中，我们将对其进行重置，并且需要先关闭它
	//调用Reset。
	mCommandList->Close();
}

ID3D12Resource* DXApp::CurrentBackBuffer() const
{
	return mSwapChainBuffer[mCurrBackBuffer].Get();
}

D3D12_CPU_DESCRIPTOR_HANDLE DXApp::CurrentBackBufferView() const
{
	return CD3DX12_CPU_DESCRIPTOR_HANDLE(
		mRtvHeap->GetCPUDescriptorHandleForHeapStart(),
		mCurrBackBuffer,
		mRtvDescriptorSize);
}

D3D12_CPU_DESCRIPTOR_HANDLE DXApp::DepthStencilView() const
{
	return mDsvHeap->GetCPUDescriptorHandleForHeapStart();
}


void DXApp::LogAdapters()
{
	UINT i = 0;
	IDXGIAdapter* adapter = nullptr;
	std::vector<IDXGIAdapter*> adapterList;
	while (mdxgiFactory->EnumAdapters(i, &adapter) != DXGI_ERROR_NOT_FOUND)
	{
		DXGI_ADAPTER_DESC desc;
		adapter->GetDesc(&desc);

		std::wstring text = L"***Adapter: ";
		text += desc.Description;
		text += L"\n";

		OutputDebugString(text.c_str());

		adapterList.push_back(adapter);

		++i;
	}

	for (size_t i = 0; i < adapterList.size(); ++i)
	{
		LogAdapterOutputs(adapterList[i]);
		ReleaseCom(adapterList[i]);
	}
}

void DXApp::LogAdapterOutputs(IDXGIAdapter* adapter)
{
	UINT i = 0;
	IDXGIOutput* output = nullptr;
	while (adapter->EnumOutputs(i, &output) != DXGI_ERROR_NOT_FOUND)
	{
		DXGI_OUTPUT_DESC desc;
		output->GetDesc(&desc);

		std::wstring text = L"***Output: ";
		text += desc.DeviceName;
		text += L"\n";
		OutputDebugString(text.c_str());

		LogOutputDisplayModes(output, mBackBufferFormat);

		ReleaseCom(output);

		++i;
	}
}

void DXApp::LogOutputDisplayModes(IDXGIOutput* output, DXGI_FORMAT format)
{
	UINT count = 0;
	UINT flags = 0; 

	// Call with nullptr to get list count.
	output->GetDisplayModeList(format, flags, &count, nullptr);

	std::vector<DXGI_MODE_DESC> modeList(count);
	output->GetDisplayModeList(format, flags, &count, &modeList[0]);

	for (auto& x : modeList)
	{
		UINT n = x.RefreshRate.Numerator;
		UINT d = x.RefreshRate.Denominator;
		std::wstring text =
			L"Width = " + std::to_wstring(x.Width) + L" " +
			L"Height = " + std::to_wstring(x.Height) + L" " +
			L"Refresh = " + std::to_wstring(n) + L"/" + std::to_wstring(d) +
			L"\n";

		::OutputDebugString(text.c_str());
	}
}

DXApp* DXApp::GetApp()
{
	return mApp;
}

HINSTANCE DXApp::AppInst() const
{
	return mhAppInst;
}

HWND DXApp::MainWnd() const
{
	return mhMainWnd;
}

float DXApp::AspectRatio() const
{
	return static_cast<float>(mClientWidth) / mClientHeight;
}

bool DXApp::Get4xMsaaState() const
{
	return m4xMsaaState;
}

void DXApp::Set4xMsaaState(bool value)
{
	if (m4xMsaaState!=value)
	{
		m4xMsaaState = value;
		//重置4xmasaa需要重新创建交换链和刷新尺寸
		CreateSwapChain();
		OnResize();

	}
}

int DXApp::Run()
{
	MSG msg = { 0 };

	mTimer.Reset();

	while (msg.message != WM_QUIT)
	{
		// If there are Window messages then process them.
		if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		// Otherwise, do animation/game stuff.
		else
		{
			mTimer.Tick();

			if (!mAppPaused)
			{
				CalculateFrameStats();
				Update(mTimer);
				Draw(mTimer);
			}
			else
			{
				Sleep(100);
			}
		}
	}

	return (int)msg.wParam;

}

void DXApp::CalculateFrameStats()
{
	// Code computes the average frames per second, and also the 
		// average time it takes to render one frame.  These stats 
		// are appended to the window caption bar.

	static int frameCnt = 0;
	static float timeElapsed = 0.0f;

	frameCnt++;

	// Compute averages over one second period.
	if ((mTimer.TotalTime() - timeElapsed) >= 1.0f)
	{
		float fps = (float)frameCnt; // fps = frameCnt / 1
		float mspf = 1000.0f / fps;

		wstring fpsStr = to_wstring(fps);
		wstring mspfStr = to_wstring(mspf);

		wstring windowText = mMainWndCaption +
			L"    fps: " + fpsStr +
			L"   mspf: " + mspfStr;

		SetWindowText(mhMainWnd, L"window text");

		// Reset for next average.
		frameCnt = 0;
		timeElapsed += 1.0f;
	}
}

LRESULT DXApp::MsgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg)
	{
		//激活或停用窗口时发送WM_ACTIVATE。
		//当停用窗口时我们暂停游戏
		//当它变为活动状态时取消暂停
	case WM_ACTIVATE:
		if (LOWORD(wParam)==WA_INACTIVE)
		{
			mAppPaused = true;
			mTimer.Stop();
		}
		else
		{
			mAppPaused = false;
			mTimer.Start();
		}
		return 0;
		// 当用户调整窗口大小时，发送WM_SIZE。
	case WM_SIZE:
		// 保存新的客户区域尺寸。
		mClientWidth = LOWORD(lParam);
		mClientHeight = HIWORD(lParam);
		if (md3dDevice)
		{
			if (wParam == SIZE_MINIMIZED)
			{
				mAppPaused = true;
				mMinimized = true;
				mMaximized = false;
			}
			else if (wParam == SIZE_MAXIMIZED)
			{
				mAppPaused = false;
				mMinimized = false;
				mMaximized = true;
				OnResize();
			}
			else if (wParam == SIZE_RESTORED)
			{

				// Restoring from minimized state?
				if (mMinimized)
				{
					mAppPaused = false;
					mMinimized = false;
					OnResize();
				}

				// Restoring from maximized state?
				else if (mMaximized)
				{
					mAppPaused = false;
					mMaximized = false;
					OnResize();
				}
				else if (mResizing)
				{
				//如果用户拖动调整大小栏，我们不会调整大小
				//这里的缓冲区，因为随着用户的不断前进
				//拖动调整大小条，WM_SIZE消息流是
				//发送到窗口，它将毫无意义（而且很慢）
				//为从拖动中收到的每个WM_SIZE消息调整大小
				//调整尺寸栏。 因此，我们在用户
				//完成调整窗口大小并释放大小调整条
				//发送WM_EXITSIZEMOVE消息。
				}
				else // API call such as SetWindowPos or mSwapChain->SetFullscreenState.
				{
					OnResize();
				}
			}
		}
		return 0;

		// 当用户抓住调整大小条时，将发送WM_EXITSIZEMOVE。
	case WM_ENTERSIZEMOVE:
		mAppPaused = true;
		mResizing = true;
		mTimer.Stop();
		return 0;

		//当用户释放大小调整条时，发送WM_EXITSIZEMOVE。
		//在这里，我们根据新窗口的尺寸重置所有内容。
	case WM_EXITSIZEMOVE:
		mAppPaused = false;
		mResizing = false;
		mTimer.Start();
		OnResize();
		return 0;
		//销毁窗口时发送WM_DESTROY。
	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;
		// 当菜单处于活动状态并且用户按下时，将发送WM_MENUCHAR消息与任何助记键或加速键都不对应的键。
	case WM_MENUCHAR:
		// 进入时不要发出哔声。
		return MAKELRESULT(0, MNC_CLOSE);


		//捕获此消息，以防止窗口变得太小。
	case WM_GETMINMAXINFO:
		((MINMAXINFO*)lParam)->ptMinTrackSize.x = 200;
		((MINMAXINFO*)lParam)->ptMinTrackSize.y = 200;
		return 0;

	case WM_LBUTTONDOWN:
	case WM_MBUTTONDOWN:
	case WM_RBUTTONDOWN:
		OnMouseDown(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
		return 0;
	case WM_LBUTTONUP:
	case WM_MBUTTONUP:
	case WM_RBUTTONUP:
		OnMouseUp(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
		return 0;
	case WM_MOUSEMOVE:
		OnMouseMove(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
		return 0;
	case WM_KEYUP:
		if (wParam == VK_ESCAPE)
		{
			PostQuitMessage(0);
		}
		else if ((int)wParam == VK_F2)
			Set4xMsaaState(!m4xMsaaState);

		return 0;
	}


	return DefWindowProc(hwnd, msg, wParam, lParam);
}

说明

帧资源

帧资源

渲染项

渲染过程中所用到的常量数据

不同形状的几何体

GeometryGenerator类

细分

中间点的生成

盒子

球体

柱体网格

构建顶部和底部

几何球体

绘制几何体示例

根签名

根参数

描述符表

根描述符

根常量

根签名复杂示例

陆地与波浪演示程序

栅格坐标

栅格索引

构建山体

动态顶点缓冲区

完整代码

自定义资源

资源类

行为类

工厂类

模块

GENERATED_BODY/GENERATED_UCLASS_BODY

.generated.h

.generated.cpp

UPROPERTY,UFUNCTION

auto

decltype

using

nullptr

枚举作用域

Lambda

explicit

default,delete

类内成员初始化

右值引用

智能指针

模板和STL方面的修改

基于范围的for循环

新的STL容器

新的STL方法

valarray升级

摒弃export

尖括号

用DirectX绘制几何体

流程简述

顶点与输入布局

顶点/索引缓冲区

顶点着色/像素着色

常量缓冲区（上传堆，CPU可写，GPU可读）

流水线状态对象 PSO

构建几何体

刷新（update）

Resize

顶点与输入布局

顶点缓冲区

索引和索引缓冲区

顶点着色器示例

布局描述符与签名匹配问题

像素着色器示例

常量缓冲区

创建常量缓冲区

更新常量缓冲区

上传缓冲区辅助函数

常量缓冲区描述符

根签名和描述符表

编译着色器

离线编译

光栅器状态

流水线状态对象

R³,标准基向量