码迷，mamicode.com
首页 > 其他好文 > 详细

Direct-X学习笔记--深度缓存

时间：2015-08-06 02:04:08      阅读：149      评论：0      收藏：0      [点我收藏+]

标签：direct3d   c++   三维   z-buffer   深度测试   

今天来学习一下深度测试，不过这个东东貌似暂时就是了解一下原理啦，因为DX默认是打开深度测试的，即我们不需要额外进行设置就可以使用深度测试的功能，不过这个还是有必要了解一下，一是对DX的流程更加了解，二是我们可以手动设置深度测试的参数以及函数，达到一些自己想要实现的效果。


一.简介

三维的世界中，有各种物体，而这些物体难免会有遮挡，而且同一个物体不同部分也会有遮挡的关系，要想表现出来更加逼真的效果，就要用到深度缓冲（Z buffer）,配套深度测试技术。

深度缓存也尝尝成为Z缓存，D3D为屏幕上每个像素点保存了一个深度值，当绘制时，D3D根据各种物体的当前像素点深度与深度缓冲区中的点的深度比较，如果测试结果为真，绘制当前像素，并且更新深度缓冲区，否则不进行绘制。

二.深度测试的步骤

使用深度缓冲区有以下四个步骤：

1.创建深度缓存区

2.开启深度测试

3.设置深度测试函数

4.更新深度缓冲区

下面分别看一下：

1.创建深度缓冲区：

这个是我们在初始化Direct时就进行的操作，之前我们已经写过啦。就是创建D3D设备时的那个结构体的两项：

	//是否开启自动深度缓冲
	d3dpp.EnableAutoDepthStencil = true;
	//当前自动深度缓冲的格式
	d3dpp.AutoDepthStencilFormat = D3DFMT_D16;//每个像素点有16位的存储空间，存储深度信息


2.开启深度测试：

还是SetRenderState函数，第一个参数为D3DRS_ZENABLE，第二个为ture或false表示是否开启深度缓冲区

//设置渲染状态，设置启用深度值
	g_pDevice->SetRenderState(D3DRS_ZENABLE, true);

3.设置深度测试函数

所谓深度测试的函数，就是一些宏，DX已经为我们写好了，我们要做的就是选择这些宏就可以啦。


4.根据深度测试函数的返回值，可以设置更新缓冲区，也可以不进行更新。DX把自由选择的权利交给了我们，让我们做出更加好的效果。



三.开启或者关闭深度测试的比较

下面是一个例子，通过空格键可以控制是否开启深度测试。

开启深度测试，“墙面”插入了龙的身体，可以看出立体效果非常的逼真：
技术分享
关闭深度测试，不仅墙面一直挡在龙的前面，连网格模型本身的绘制也出了问题，人物“反过来了”。
技术分享

这里要注意一个问题：为什么人物会反过来，如果不适用深度测试的话，DX默认会使用画家算法，即先画的东东都在后面，后画的东东在前面，而不会去考虑可能有的遮罩关系，而使用了ZBuffer,就可以更好的确定物体之间，或者物体本身的遮罩关系啦。

// D3DDemo.cpp : 定义应用程序的入口点。
//

#include "stdafx.h"
#include "D3DDemo.h"
#include "DirectInput.h"
#include "Camera.h"
#include "Terrain.h"
#include "Mesh.h"

#define MAX_LOADSTRING 100


// 全局变量:
HINSTANCE hInst;								// 当前实例
TCHAR szTitle[MAX_LOADSTRING];					// 标题栏文本
TCHAR szWindowClass[MAX_LOADSTRING];			// 主窗口类名

// 此代码模块中包含的函数的前向声明:
HWND                g_hWnd;
ATOM				MyRegisterClass(HINSTANCE hInstance);
BOOL				InitInstance(HINSTANCE, int);
LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);

//---------改造3D窗口需要的内容------------
LPDIRECT3D9 g_pD3D = NULL;				//D3D接口指针
LPDIRECT3DDEVICE9 g_pDevice = NULL;		//D3D设备指针
CDirectInput* g_pDirectInput = NULL;	//控制指针
CCamera*      g_pCamera      = NULL;    //摄像机指针
CTerrain*     g_pTerrian     = NULL;	//地形类指针
CMesh*        g_pMesh1       = NULL;	//网格对象指针1
CMesh*        g_pMesh2       = NULL;	//网格对象指针2
CMesh*		  g_pMesh3       = NULL;	//网格对象指针3
LPD3DXMESH    g_pMeshWall    = NULL;	//墙壁的网格指针



LPDIRECT3DTEXTURE9  g_pGroundTexture = NULL;	//地面纹理
D3DXMATRIX g_matWorld;							//世界矩阵

void onCreatD3D()
{
	g_pD3D = Direct3DCreate9(D3D_SDK_VERSION);
	if (!g_pD3D)
		return;

	//检测硬件设备能力的方法
	/*D3DCAPS9 caps;
	ZeroMemory(&caps, sizeof(caps));
	g_pD3D->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps);*/

	//获得相关信息，屏幕大小，像素点属性
	D3DDISPLAYMODE d3ddm;
	ZeroMemory(&d3ddm, sizeof(d3ddm));

	g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm);


	//设置全屏模式
	D3DPRESENT_PARAMETERS d3dpp;
	ZeroMemory(&d3dpp, sizeof(d3dpp));
	/*d3dpp.Windowed = false;
	d3dpp.BackBufferWidth = d3ddm.Width;
	d3dpp.BackBufferHeight = d3ddm.Height;*/

	d3dpp.Windowed = true;
	d3dpp.BackBufferFormat = d3ddm.Format;
	d3dpp.BackBufferCount = 1;

	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;//交换后原缓冲区数据丢弃

	//是否开启自动深度缓冲
	d3dpp.EnableAutoDepthStencil = true;
	//当前自动深度缓冲的格式
	d3dpp.AutoDepthStencilFormat = D3DFMT_D16;//每个像素点有16位的存储空间，存储离摄像机的距离
	

	g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, g_hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &g_pDevice);

	if (!g_pDevice)
		return;

	//设置渲染状态，设置启用深度值
	g_pDevice->SetRenderState(D3DRS_ZENABLE, false);

	//设置渲染状态，关闭灯光
	g_pDevice->SetRenderState(D3DRS_LIGHTING, false);

	//设置渲染状态，裁剪模式
	g_pDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);

}

void CreateMesh()
{
	g_pMesh1 = new CMesh(g_pDevice);
	g_pMesh1->CreateMesh("miki.X");

	g_pMesh2 = new CMesh(g_pDevice);
	g_pMesh2->CreateMesh("Demon.X");

	g_pMesh3 = new CMesh(g_pDevice);
	g_pMesh3->CreateMesh("dragon.X");

	D3DXCreateBox(g_pDevice, 50.0f, 50.0f, 1.0f, &g_pMeshWall, NULL);
}

void CreateCamera()
{
	g_pCamera = new CCamera(g_pDevice);
	g_pCamera->SetCameraPosition(&D3DXVECTOR3(0.0f, 500.0f, -500.0f));
	g_pCamera->SetTargetPosition(&D3DXVECTOR3(0.0f, 500.0f, 0.0f));
	g_pCamera->SetViewMatrix();
	g_pCamera->SetProjectionMartix();
}

void CreateTerrain()
{
	g_pTerrian = new CTerrain(g_pDevice);
	g_pTerrian->LoadTerrainFromFile(TEXT("heighmap.raw"), TEXT("terraintexture.jpg"));
	g_pTerrian->InitTerrain(200, 200, 30.0f, 3.0f);
}



void onInit()
{
	//初始化D3D
	onCreatD3D();

	//初始化顶点缓冲区
	initVB();

	//创建Mesh模型
	CreateMesh();

	//创建摄像机
	CreateCamera();

	//创建地形
	CreateTerrain();
	
}



void onDestroy()
{
	SAFE_DELETE(g_pDirectInput);
	SAFE_DELETE(g_pCamera);
	SAFE_DELETE(g_pTerrian);
	SAFE_RELEASE(g_pDevice);
}

void onLogic(float fElapsedTime)
{
	//使用DirectInput类读取数据
	g_pDirectInput->GetInput();

	// 沿摄像机各分量移动视角
	if (g_pDirectInput->IsKeyDown(DIK_A))  g_pCamera->MoveAlongRightVec(-10.0f);
	if (g_pDirectInput->IsKeyDown(DIK_D))  g_pCamera->MoveAlongRightVec( 10.0f);
	if (g_pDirectInput->IsKeyDown(DIK_W)) g_pCamera->MoveAlongLookVec( 10.0f);
	if (g_pDirectInput->IsKeyDown(DIK_S))  g_pCamera->MoveAlongLookVec(-10.0f);
	if (g_pDirectInput->IsKeyDown(DIK_I))  g_pCamera->MoveAlongUpVec( 10.0f);
	if (g_pDirectInput->IsKeyDown(DIK_K))  g_pCamera->MoveAlongUpVec(-10.0f);

	//沿摄像机各分量旋转视角
	if (g_pDirectInput->IsKeyDown(DIK_LEFT))  g_pCamera->RotationUpVec(-0.003f);
	if (g_pDirectInput->IsKeyDown(DIK_RIGHT))  g_pCamera->RotationUpVec( 0.003f);
	if (g_pDirectInput->IsKeyDown(DIK_UP))  g_pCamera->RotationRightVec(-0.003f);
	if (g_pDirectInput->IsKeyDown(DIK_DOWN))  g_pCamera->RotationRightVec( 0.003f);
	if (g_pDirectInput->IsKeyDown(DIK_J)) g_pCamera->RotationLookVec(-0.001f);
	if (g_pDirectInput->IsKeyDown(DIK_L)) g_pCamera->RotationLookVec( 0.001f);

	//鼠标控制右向量和上向量的旋转
	//g_pCamera->RotationUpVec(g_pDirectInput->MouseDX()* 0.001f);
	//g_pCamera->RotationRightVec(g_pDirectInput->MouseDY() * 0.001f);

	//鼠标滚轮控制观察点收缩操作
	static FLOAT fPosZ=0.0f;
	fPosZ += g_pDirectInput->MouseDZ()*3.0f;

	//计算并设置取景变换矩阵
	D3DXMATRIX matView;
	g_pCamera->CalculateViewMatrix(&matView);
	g_pDevice->SetTransform(D3DTS_VIEW, &matView);

	//把正确的世界变换矩阵存到g_matWorld中
	D3DXMatrixTranslation(&g_matWorld, 0.0f, 0.0f, fPosZ);

	static bool m_bIsZbufferOn;
<span style="white-space:pre">	</span>//设置是否开启深度测试
	if (g_pDirectInput->IsKeyDown(DIK_SPACE))
	{
		m_bIsZbufferOn = !m_bIsZbufferOn;
		g_pDevice->SetRenderState(D3DRS_ZENABLE, m_bIsZbufferOn);
	}
}

void onRender(float fElasedTime)
{
	//前两个参数是0和NULL时，清空整个游戏窗口的内容（清的是后台）
	//第三个是清除的对象：前面表示清除颜色缓冲区，后面表示清除深度缓冲区,D3DCLEAR_STENCIL清空模板缓冲区
	g_pDevice->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0,100,100), 1.0f, 0);

	g_pDevice->BeginScene();

	D3DXMATRIX matWorld1, matWorld2, matWorld3, matWorld4;  
	D3DXMatrixTranslation(&matWorld1, 0.0f, 600.0f, 0.0f);  
	D3DXMatrixTranslation(&matWorld2, 500.0f, 500.0f, 0.0f);
	D3DXMatrixTranslation(&matWorld3, 0.0f, 500.0f, 0.0f);
	D3DXMatrixTranslation(&matWorld4, 0.0f, 0.0f, 0.0f);
	g_pMesh1->DrawMesh(matWorld1);
	g_pMesh2->DrawMesh(matWorld2);
	g_pMesh3->DrawMesh(matWorld3);
	g_pMeshWall->DrawSubset(0);

	//g_pTerrian->RenderTerrain(&matWorld4, false);

	g_pDevice->EndScene();


	g_pDevice->Present(NULL, NULL, NULL, NULL);
}


int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPTSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);

 	// TODO: 在此放置代码。
	MSG msg;
	HACCEL hAccelTable;

	// 初始化全局字符串
	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadString(hInstance, IDC_D3DDEMO, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);

	// 执行应用程序初始化:
	if (!InitInstance (hInstance, nCmdShow))
	{
		return FALSE;
	}

	hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_D3DDEMO));

	

	ZeroMemory(&msg, sizeof(msg));
	while (msg.message != WM_QUIT)
	{
		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		else
		{
			static DWORD dwTime = timeGetTime();
			DWORD dwCurrentTime = timeGetTime();
			DWORD dwElapsedTime = dwCurrentTime - dwTime;
			float fElapsedTime = dwElapsedTime * 0.001f;

			//------------渲染和逻辑部分代码----------
			onLogic(fElapsedTime);
			onRender(fElapsedTime);
			//-----------------------------------------
			if (dwElapsedTime < 1000 / 60)
			{
				Sleep(1000/ 60 - dwElapsedTime);
			}
			dwTime = dwCurrentTime;
		}
	}

	onDestroy();
	return (int) msg.wParam;
}



//
//  函数: MyRegisterClass()
//
//  目的: 注册窗口类。
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);

	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_D3DDEMO));
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_D3DDEMO);
	wcex.lpszClassName	= szWindowClass;
	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

	return RegisterClassEx(&wcex);
}

//
//   函数: InitInstance(HINSTANCE, int)
//
//   目的: 保存实例句柄并创建主窗口
//
//   注释:
//
//        在此函数中，我们在全局变量中保存实例句柄并
//        创建和显示主程序窗口。
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{

   hInst = hInstance; // 将实例句柄存储在全局变量中

   g_hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

   if (!g_hWnd)
   {
      return FALSE;
   }

  //初始化DirectInput类
   g_pDirectInput = new CDirectInput();
   g_pDirectInput->Init(g_hWnd, hInst, DISCL_FOREGROUND|DISCL_NONEXCLUSIVE, DISCL_FOREGROUND|DISCL_NONEXCLUSIVE);

   SetMenu(g_hWnd, NULL);
   ShowWindow(g_hWnd, nCmdShow);
   UpdateWindow(g_hWnd);

   onInit();

   return TRUE;
}

//
//  函数: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  目的: 处理主窗口的消息。
//
//  WM_COMMAND	- 处理应用程序菜单
//  WM_PAINT	- 绘制主窗口
//  WM_DESTROY	- 发送退出消息并返回
//
//
LRESULT CALLBACK WndProc(HWND g_hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
	case WM_KEYDOWN:
		if (wParam == VK_ESCAPE)
			PostQuitMessage(0);
		break;
	case WM_CLOSE:
		DestroyWindow(g_hWnd);
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(g_hWnd, message, wParam, lParam);
	}
	return 0;
}



可见，深度缓冲在3D世界中是很重要的功能呢，如果我们不是需要做太多的操作的话，DX默认的深度测试就可以啦，如果我们还想做出某些奇葩的效果，就可以换一些深度测试的设定。


版权声明：本文为博主原创文章，未经博主允许不得转载。

Direct-X学习笔记--深度缓存

标签：direct3d   c++   三维   z-buffer   深度测试   

原文地址：http://blog.csdn.net/puppet_master/article/details/47307277
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！