DirectX 3D_实践之DirectX3D中的融合技术

最新推荐文章于 2021-11-02 17:10:26 发布

Z18_28_19

最新推荐文章于 2021-11-02 17:10:26 发布

阅读量1.9k

点赞数

分类专栏：我的DirectX3D学习

本文链接：https://blog.csdn.net/Z18_28_19/article/details/9008059

版权

我的DirectX3D学习专栏收录该内容

33 篇文章 2 订阅

订阅专栏

身为80后的一代，作为目前社会中的中间力量，我们理所当然的应该去奋斗。我们承担着许多责任，在这许多的责任当中，我们不应该躲避，而是勇敢的承担起，每个人都应该有梦想，而且都应该为这个梦想奋勇前进，前面荆棘，坎坷，困难无数，我们不怕，只要心中有梦，像歌中唱的一样，有梦想，谁都了不起。做为30岁左右的我们，正是事业发展的黄金年龄，我们不应该害怕，应该有强大的内心，信心，去克服一切路上遇到的艰难。

我们今天看一下，Direct3D中的融合处理，我们将，即将正在处理的图元颜色值与存储在后台缓存中的像素颜色值进行合成的技术，称为融合。利用该技术，我们可以得到各种各样的效果，尤其是透明效果。

先看一下，DirectX3D.h

#ifndef __DirectX3DH__
#define __DirectX3DH__

#include <d3dx9.h>
#include <string>

namespace d3d
{
	bool InitD3D(
		HINSTANCE hInstance,       // [in] Application instance.
		int width, int height,     // [in] Backbuffer dimensions.
		bool windowed,             // [in] Windowed (true)or full screen (false).
		D3DDEVTYPE deviceType,     // [in] HAL or REF
		IDirect3DDevice9** device);// [out]The created device.
	
	int EnterMsgLoop( 
		bool (*ptr_display)(float timeDelta));
	
	LRESULT CALLBACK WndProc(
		HWND hwnd,
		UINT msg, 
		WPARAM wParam,
		LPARAM lParam);
	
	template<class T> void Release(T t)
	{
		if( t )
		{
			t->Release();
			t = 0;
		}
	}
	
	template<class T> void Delete(T t)
	{
		if( t )
		{
			delete t;
			t = 0;
		}
	}
	
	const D3DXCOLOR      WHITE( D3DCOLOR_XRGB(255, 255, 255) );
	const D3DXCOLOR      BLACK( D3DCOLOR_XRGB(  0,   0,   0) );
	const D3DXCOLOR        RED( D3DCOLOR_XRGB(255,   0,   0) );
	const D3DXCOLOR      GREEN( D3DCOLOR_XRGB(  0, 255,   0) );
	const D3DXCOLOR       BLUE( D3DCOLOR_XRGB(  0,   0, 255) );
	const D3DXCOLOR     YELLOW( D3DCOLOR_XRGB(255, 255,   0) );
	const D3DXCOLOR       CYAN( D3DCOLOR_XRGB(  0, 255, 255) );
	const D3DXCOLOR    MAGENTA( D3DCOLOR_XRGB(255,   0, 255) );
	
	//
	// Lights
	//
	
	D3DLIGHT9 InitDirectionalLight(D3DXVECTOR3* direction, D3DXCOLOR* color);
	D3DLIGHT9 InitPointLight(D3DXVECTOR3* position, D3DXCOLOR* color);
	D3DLIGHT9 InitSpotLight(D3DXVECTOR3* position, D3DXVECTOR3* direction, D3DXCOLOR* color);
	
	//
	// Materials
	//
	
	D3DMATERIAL9 InitMtrl(D3DXCOLOR a, D3DXCOLOR d, D3DXCOLOR s, D3DXCOLOR e, float p);
	
	const D3DMATERIAL9 WHITE_MTRL  = InitMtrl(WHITE, WHITE, WHITE, BLACK, 2.0f);
	const D3DMATERIAL9 RED_MTRL    = InitMtrl(RED, RED, RED, BLACK, 2.0f);
	const D3DMATERIAL9 GREEN_MTRL  = InitMtrl(GREEN, GREEN, GREEN, BLACK, 2.0f);
	const D3DMATERIAL9 BLUE_MTRL   = InitMtrl(BLUE, BLUE, BLUE, BLACK, 2.0f);
	const D3DMATERIAL9 YELLOW_MTRL = InitMtrl(YELLOW, YELLOW, YELLOW, BLACK, 2.0f);	

}




#endif

在看一下DirectX3D.cpp

#include "DirectX3D.h"






bool d3d::InitD3D(
	HINSTANCE hInstance,
	int width, int height,
	bool windowed,
	D3DDEVTYPE deviceType,
	IDirect3DDevice9** device)
{
	//
	// Create the main application window.
	//

	WNDCLASS wc;

	wc.style         = CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc   = (WNDPROC)d3d::WndProc; 
	wc.cbClsExtra    = 0;
	wc.cbWndExtra    = 0;
	wc.hInstance     = hInstance;
	wc.hIcon         = LoadIcon(0, IDI_APPLICATION);
	wc.hCursor       = LoadCursor(0, IDC_ARROW);
	wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
	wc.lpszMenuName  = 0;
	wc.lpszClassName = "Direct3D9App";

	if( !RegisterClass(&wc) ) 
	{
		::MessageBox(0, "RegisterClass() - FAILED", 0, 0);
		return false;
	}
		
	HWND hwnd = 0;
	hwnd = ::CreateWindow("Direct3D9App", "Direct3D9App", 
		WS_EX_TOPMOST,
		0, 0, width, height,
		0 /*parent hwnd*/, 0 /* menu */, hInstance, 0 /*extra*/); 

	if( !hwnd )
	{
		::MessageBox(0, "CreateWindow() - FAILED", 0, 0);
		return false;
	}

	::ShowWindow(hwnd, SW_SHOW);
	::UpdateWindow(hwnd);

	//
	// Init D3D: 
	//

    //第一步
    //要初始化IDirect3D 首先必须获取IDirect3D9的指针，使用一个专门的Direct3D函数就可以很容易做到
     IDirect3D9 * _d3d9;
  
  //这个对象的主要有两个用途：设备枚举以及创建IDirect3DDevice9类型的对象。设备枚举是指获取系统中可用的的每块图形卡的
  //性能，显示模型，格式以及其他信息。这个函数调用失败会返回一个NULL指针。
  if(NULL == (_d3d9 = Direct3DCreate9(D3D_SDK_VERSION))){


    return FALSE;

  }

  //第二步
  //创建一个代表主显卡的IDirect3DDevice9类型对象时，必须指定使用该对象进行顶点运算的类型。如果可以，我们希望使用硬件顶点运算
  //但是由于并非所有的显卡都支持硬件顶点运算，我们必须首先检查图形卡是否支持该类型的运算。

  //要进行检查，必须先根据主显卡的性能参数初始化一个IDirect3DDevice9类型的对象。我们使用如下方法来完成初始化：
     /*
  HRESULT IDirect3D9:GetDeviceCaps(
      UINT Adapter,
      D3DDEVTYPE DeviceType,
      D3DCAPS9 * pCaps;
   
  )

        Adapter : 指定物理显卡的序号。
  DeviceType：指定设备类(例如硬件设备（D3DDEVTYPE_HAL）或软件设备（D3DDEVTYPE_REF）);
  pCaps 返回已初始化的设备性能结构实例。
        */
         D3DCAPS9 caps; 
         int vp = 0; //代表顶点如何操作

        _d3d9->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps);

          if(caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT){

                        vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;
           }
          else
          {
                        vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
          }

          //第三步是填充D3DPRESENT_PARAMETER结构
          //该结构用于指定所要创建的IDirect3DDevice9类型对象的一些特性，该结构定义如下：
          /*
          typedef struct _D3DPRESENT_PARAMETERS_{
                        UINT BackBufferWidth;
                        UINT BackBufferHeight;
                        UINT BackBufferFormat;
                        UINT BackBufferCount;
                        D3DMULTISAMPLE_TYPE MultiSampleType;
                        DWORD MultiSampleQuality;
                        D3DSWAPEFFECT SwapEffect;
                        HWND  hDeviceWindow;
                        BOOL  Windowed;
                        BOOL  EnableAutoDepthStencil;
                        D3DFORMAT AutoDepthStencilFormat;
                        DWORD  Flags;
                        UINT   FullScreen_RefreshRateInHz;
                        UINT   PresentationInterval;
          }; 
         */
        
        /* 
         BackBufferWidth: 后台缓存中表面的宽度，单位为像素。
        BackBufferHeight:后台缓存中表面的高度，单位为像素。
        BackBufferFormat:后台缓存的像素格式(如32位像素格式：D3DFMT_A8R8G8B8);
        BackBufferCount: 所需使用的后台缓存的个数，通常指定为1，表明我们仅需要一个后台缓存。
        MultiSampleType: 后台缓存所使用的多重采样类型。
        MultiSampleQuality:多重采样的质量水平。
        SwapEffect:D3DSWAPEFFECT 枚举类型的一个成员。该枚举类型指定了交换链中的缓存的页面置换方式。指定D3DSWAPEFFECT_DISCARD时效率最高。
        hDeviceWindow:与设备相关的窗口句柄。指定了所要进行绘制的应用程序窗口。
        Windowed:为true时表示窗口模式，false时为全屏模式
        EnableAutoDepthStencil:设为true，则Direct3D自动创建并维护深度缓存或模板缓存。
        AutoDepthStencilFormat:深度缓存或模板缓存的像素格式(例如，用24位表示深度并将8位保留供模板缓存使用，D3DFMT_D24S8).
        Flags:一些附加的特性。可以指定为0，表示无标记，或D3DPRESENTFLAG集合中的一个成员，其中两个成员较常用。
                 D3DPRESENTFLAG_LOCKABLE_DEPTHBUFFER 指定为可锁定的后台缓存。注意，使用一个可锁定的后台缓存会降低性能。
                 D3DPRESENTFLAG_DISCARD_DEPTHBUFFER 指定当下一个后台缓存提交时，哪个深度或模块缓存将被丢弃。丢弃的意思是深度或模板缓存存储区
                                                    中的内容别丢弃或无效。这样可以提升性能。
        FullScreen_RefreshRateInHz: 刷新频率，如果想使用默认的刷新频率，则可将该参数指定为D3DPRESENT_RATE_DEFAULT;
        PresentationInterval:D3DPRESENT集合的一个成员，其中有两个比较常用。
                      D3DPRESENT_INTERVAL_IMMEDIATE 立即提交。
                      D3DPRESENT_INTERVAL_DEFAULT 由Direct3D来选择提交频率，通常该值等于刷新频率。
       */ 

                  D3DPRESENT_PARAMETERS d3dpp;  
                  ZeroMemory(&d3dpp, sizeof(d3dpp));  
                 d3dpp.BackBufferWidth            = 800;  
                 d3dpp.BackBufferHeight           = 600;  
                 d3dpp.BackBufferFormat           = D3DFMT_A8R8G8B8;  
                 d3dpp.BackBufferCount            = 1;  
                 d3dpp.MultiSampleType            = D3DMULTISAMPLE_NONE;  
                 d3dpp.MultiSampleQuality         = 0;  
                 d3dpp.SwapEffect                 = D3DSWAPEFFECT_DISCARD;   
                 d3dpp.hDeviceWindow              = hwnd;  
                 d3dpp.Windowed                   = true;  
                 d3dpp.EnableAutoDepthStencil     = true;   
                 d3dpp.AutoDepthStencilFormat     = D3DFMT_D24S8;  
                 d3dpp.Flags                      = 0;  
                 d3dpp.FullScreen_RefreshRateInHz = 0;  
                 d3dpp.PresentationInterval       = D3DPRESENT_INTERVAL_IMMEDIATE; 

              //第四步 创建IDirectDevice9类型的对象
               /*  
                       HRESULT IDirect3D9::CreateDevice(
                               UINT Adapter,
                               D3DDEVTYPE DeviceType,
                               HWND hFocusWindow,
                               DWORD BehaviorFlags,
                               D3DPRESENT_PARAMETERS *pPresentationParameters,
                               IDirect3DDevice9 ** ppReturnedDeviceInterface
   
   
                       );

       Adapter:指定我们希望用已创建的IDirect3DDevice9对象代表哪块物理显卡。
       DeviceType:指定需要使用的设备类型()如，硬件设备用D3DDEVTYPE_HAL,或D3DDEVTYPE_REF代表软件设备。
       hFocusWindow:与设备相关的窗口句柄。通常情况下是指设备所要进行绘制的目标窗口。
       为了达到预期的目的，该句柄与D3DPRESENT_PARAMETER结构的数据成员hDeviceWindow应为同一个句柄。
       BehaviorFlags:该参数可为D3DCREATE_HARDWARE_VERTEXPROCESSING或D3DCREATE_SOFTWARE_VERTEXPROCESSING.
       pPresentationParameters:一个已经完成初始化的D3DPRESENT_PARAMETERS类型的实例，该实例定义了设备的一些特性。
       ppReturnedDeviceInterface:返回所创建的设备。
*/
  if(FAILED(_d3d9->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,   
   hwnd, vp, &d3dpp, device)))  
           return FALSE;  

      _d3d9->Release();

      return TRUE;


}

int d3d::EnterMsgLoop( bool (*ptr_display)(float timeDelta) )
{
	MSG msg;
	::ZeroMemory(&msg, sizeof(MSG));

	static float lastTime = (float)timeGetTime(); 

	while(msg.message != WM_QUIT)
	{
		if(::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
		{
			::TranslateMessage(&msg);
			::DispatchMessage(&msg);
		}
		else
        {	
			float currTime  = (float)timeGetTime();
			float timeDelta = (currTime - lastTime)*0.001f;

			ptr_display(timeDelta);

			lastTime = currTime;
        }
    }
    return msg.wParam;
}


D3DLIGHT9 d3d::InitDirectionalLight(D3DXVECTOR3* direction, D3DXCOLOR* color)
{
	D3DLIGHT9 light;
	::ZeroMemory(&light, sizeof(light));
	
	light.Type      = D3DLIGHT_DIRECTIONAL;
	light.Ambient   = *color * 0.4f;
	light.Diffuse   = *color;
	light.Specular  = *color * 0.6f;
	light.Direction = *direction;
	
	return light;
}

D3DLIGHT9 d3d::InitPointLight(D3DXVECTOR3* position, D3DXCOLOR* color)
{
	D3DLIGHT9 light;
	::ZeroMemory(&light, sizeof(light));
	
	light.Type      = D3DLIGHT_POINT;
	light.Ambient   = *color * 0.4f;
	light.Diffuse   = *color;
	light.Specular  = *color * 0.6f;
	light.Position  = *position;
	light.Range        = 1000.0f;
	light.Falloff      = 1.0f;
	light.Attenuation0 = 1.0f;
	light.Attenuation1 = 0.0f;
	light.Attenuation2 = 0.0f;
	
	return light;
}

D3DLIGHT9 d3d::InitSpotLight(D3DXVECTOR3* position, D3DXVECTOR3* direction, D3DXCOLOR* color)
{
	D3DLIGHT9 light;
	::ZeroMemory(&light, sizeof(light));
	
	light.Type      = D3DLIGHT_SPOT;
	light.Ambient   = *color * 0.4f;
	light.Diffuse   = *color;
	light.Specular  = *color * 0.6f;
	light.Position  = *position;
	light.Direction = *direction;
	light.Range        = 1000.0f;
	light.Falloff      = 1.0f;
	light.Attenuation0 = 1.0f;
	light.Attenuation1 = 0.0f;
	light.Attenuation2 = 0.0f;
	light.Theta        = 0.5f;
	light.Phi          = 0.7f;
	
	return light;
}

D3DMATERIAL9 d3d::InitMtrl(D3DXCOLOR a, D3DXCOLOR d, D3DXCOLOR s, D3DXCOLOR e, float p)
{
	D3DMATERIAL9 mtrl;
	mtrl.Ambient  = a;
	mtrl.Diffuse  = d;
	mtrl.Specular = s;
	mtrl.Emissive = e;
	mtrl.Power    = p;
	return mtrl;
}

最后看一下，wmain.cpp

#include "DirectX3D.h"
#include <fstream>
#include <vector>
//
// Globals
//

IDirect3DDevice9* Device = 0; 

ID3DXMesh * Teapot = 0;

D3DMATERIAL9 TeapotMtrl;

IDirect3DTexture9 * BkGndTex = 0;


D3DMATERIAL9 BkGndMtrl;

IDirect3DVertexBuffer9 * BkGndQuad;


struct Vertex
{
	Vertex(){}
	
	Vertex(float x, float y, float z, float nx, float ny, float nz,float u,float v)
	{
		_x  = x;  _y  = y;	_z  = z;
		_nx = nx; _ny = ny; _nz = nz;
		_u = u;_v = v;
	}
	float  _x,  _y,  _z;
	float _nx, _ny, _nz;
	float _u,_v;
	
	static const DWORD FVF;
};
const DWORD Vertex::FVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1;

//初始化两个全局常量，以定义屏幕的分辨率。r
const int Width = 800;
const int Height = 600;


//
// Framework Functions
//
//面我们在Setup函数里面创建顶点缓存和索引缓存，
//然后对缓存进行锁定，这里我们没有用到索引缓存
bool Setup()
{

    //茶壶的材质的设置
	TeapotMtrl = d3d::RED_MTRL;
/*
	TeapotMtrl.Ambient = D3DCOLOR_XRGB(255,   0,   0,0); //反射所有的红色环境光
	TeapotMtrl.Diffuse = D3DCOLOR_XRGB(255,   0,   0);//反射所有的红色漫射光
	TeapotMtrl.Specular = D3DCOLOR_XRGB(255,   0,   0);//反射所有的红色漫射光
	TeapotMtrl.Emissive = D3DCOLOR_XRGB(0,   0,   0);//增强物体的亮度，使之看起来好像自己发光
	TeapotMtrl.Power = 2.0f; //增加镜面高光点的锐度，
*/
	TeapotMtrl.Diffuse.a = 0.5f;//Set Alpha to 50% opacity

	BkGndMtrl = d3d::WHITE_MTRL;

    //后台物体的材质的设置
/*
	BkGndMtrl.Ambient = D3DCOLOR_XRGB(255,   255,   255); //反射所有的白色环境光
	BkGndMtrl.Diffuse = D3DCOLOR_XRGB(255,   255,   255);//反射所有的白色漫射光
	BkGndMtrl.Specular = D3DCOLOR_XRGB(255,   255,   255);//反射所有的白色漫射光
	BkGndMtrl.Emissive = D3DCOLOR_XRGB(0,   0,   0);//增强物体的亮度，使之看起来好像自己发光
	BkGndMtrl.Power = 2.0f; //增加镜面高光点的锐度，
*/


	D3DXCreateTeapot(Device, &Teapot, 0);

	//
	// Create the background quad.
	//

	Device->CreateVertexBuffer(
		6 * sizeof(Vertex), 
		D3DUSAGE_WRITEONLY,
		Vertex::FVF,
		D3DPOOL_MANAGED,
		&BkGndQuad,
		0);

	Vertex* v;
	BkGndQuad->Lock(0, 0, (void**)&v, 0);

	v[0] = Vertex(-10.0f, -10.0f, 5.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
	v[1] = Vertex(-10.0f,  10.0f, 5.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
	v[2] = Vertex( 10.0f,  10.0f, 5.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);

	v[3] = Vertex(-10.0f, -10.0f, 5.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
	v[4] = Vertex( 10.0f,  10.0f, 5.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);
	v[5] = Vertex( 10.0f, -10.0f, 5.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f);

	BkGndQuad->Unlock();



    //
	// 设置方向光
	//

	//
	//

	D3DLIGHT9 dir;
	::ZeroMemory(&dir, sizeof(dir));
	dir.Type      = D3DLIGHT_DIRECTIONAL;
	dir.Diffuse   = d3d::GREEN;
	dir.Specular  = d3d::WHITE * 0.2f;
	dir.Ambient   = d3d::WHITE * 0.6f;
	dir.Direction = D3DXVECTOR3(0.707f, 0.0f, 0.707f);
	
	Device->SetLight(0, &dir);
	Device->LightEnable(0, true);

	Device->SetRenderState(D3DRS_NORMALIZENORMALS, true);
	Device->SetRenderState(D3DRS_SPECULARENABLE, true);
    
    //创建纹理
	/*
	这个函数的参数比较简单
	*/
    D3DXCreateTextureFromFile(
		Device,
		"crate.jpg",
		&BkGndTex
		);
	
	
//	Device->SetTexture(0,Tex);
	
    /*
	设置纹理的采样过滤器状态
	*/
	
	//线性纹理过滤，将线性纹理过滤设置为放大过滤器和缩小过滤器。效果依据硬件水平。
	//Device->SetSamplerState(0,D3DSAMP_MAGFILTER,D3DTEXF_LINEAR);
	//Device->SetSamplerState(0,D3DSAMP_MINFILTER,D3DTEXF_LINEAR);
	
	//最近采样点纹理过滤设置为放大过滤器和缩小过滤器。效果最差
	//Device->SetSamplerState(0,D3DSAMP_MAGFILTER,D3DTEXF_POINT);
	//Device->SetSamplerState(0,D3DSAMP_MINFILTER,D3DTEXF_POINT);

	//各向异性纹理过滤设置为放大过滤器和缩小过滤器。效果最好
	//Device->SetSamplerState(0,D3DSAMP_MAGFILTER,D3DTEXF_ANISOTROPIC);
	//Device->SetSamplerState(0,D3DSAMP_MINFILTER,D3DTEXF_ANISOTROPIC);

    //多级渐近纹理过滤器。
	//Device->SetSampleState(0,D3DSAMP_MIPFILTER,Filter);
	//Filter可以取如下值：
	/*
	D3DTEXF_NONE 禁用多级渐进纹理过滤器
	D3DTEXF_POINT 通过使用该过滤器，DirectX3D将尺寸与屏幕三角形最接近的那一级纹理，一旦选择了某一级纹理
	Direct3D就会用指定的放大过滤器和放小过滤器对该级纹理进行过滤
	D3DTEXF_LINEAR 通过使用该过滤器，Direct3D将取与屏幕三角形尺寸最接近的两个纹理级，用指定的放大器和缩小过滤器
	对每级纹理进行过滤，然后再将两级纹理进行线性组合，从而形成最终的颜色值。

  	*/
	Device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
	Device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
	Device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
	
	//设置 Alpha的来源来自材质。我们来回忆一下，这个绘制状态的参数。
	/*
	这里我们指定Alpha的来源，因为之前我们设置了材质的漫反射光的颜色值的Alpha，所以这里我们选择为慢反射颜色值。
	当然，我们也可以指定，Alpha的值来源于纹理。
	例如：
	Device->SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_TEXTURE);
	
	Device->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_SELECTARG1);
	
	
	*/
    Device->SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_DIFFUSE);
	
	Device->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_SELECTARG1);
	
	//通过绘制状态的设置对源融合因子和目标融合因子进行设置
	
	Device->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
	
	Device->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);

	//
	// 设置摄像机的位置，我们把从世界坐标系到到观察坐标系的变换，称为取景变换。
	//
	
	D3DXVECTOR3 pos(0.0f, 0.0f, -3.0f); // 摄像机在世界坐标系中的坐标
	D3DXVECTOR3 target(0.0f, 0.0f, 0.0f); //世界坐标系中的被观察点
	D3DXVECTOR3 up(0.0f, 1.0f, 0.0f); // 世界坐标系中的向上方向的向量。
	D3DXMATRIX V;
	D3DXMatrixLookAtLH(&V, &pos, &target, &up);
	
	Device->SetTransform(D3DTS_VIEW, &V);
	
	//
	// 设置投影矩阵
	//
	
	D3DXMATRIX proj;
	D3DXMatrixPerspectiveFovLH(
		&proj,
		D3DX_PI * 0.5f, // 90 - degree
		(float)Width / (float)Height,
		1.0f,
		1000.0f);

	Device->SetTransform(D3DTS_PROJECTION, &proj);



	return true;
}
//将之前分配的内存进行清理，也就是顶点缓存和索引缓存
void Cleanup()
{

	d3d::Release<IDirect3DVertexBuffer9*>(BkGndQuad);
	d3d::Release<ID3DXMesh*>(Teapot);
	d3d::Release<IDirect3DTexture9*>(BkGndTex);

	// Nothing to cleanup in this sample.
}

/*
这里的Display在两个不同的位置以两种不同的着色模式分别绘制了Triangle。每个三角形的位置由世界变换矩阵World来控制

*/

bool Display(float timeDelta)
{
	if( Device )
	{
		// 
		// 通过键盘的输入，调整ALPHA的值。
		//
 
		 
		if(::GetAsyncKeyState('A')& 0x8000f)
			TeapotMtrl.Diffuse.a += 0.01f;

		if(::GetAsyncKeyState('S')& 0x8000f)
			TeapotMtrl.Diffuse.a -= 0.01f;

		//强制是Alpha的值在0到1之间
		if(TeapotMtrl.Diffuse.a > 1.0f)
			TeapotMtrl.Diffuse.a = 1.0f;
		if(TeapotMtrl.Diffuse.a < 0.0f)
			TeapotMtrl.Diffuse.a = 0.0f;

		//进行绘制
		Device->Clear(0,0,D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,0xffffffff,1.0f,0);

		Device->BeginScene();

		D3DXMATRIX W;

        D3DXMatrixIdentity(&W);

		Device->SetTransform(D3DTS_WORLD,&W);

		Device->SetFVF(Vertex::FVF);

		Device->SetStreamSource(0,BkGndQuad,0,sizeof(Vertex));

		Device->SetMaterial(&BkGndMtrl);

		Device->SetTexture(0,BkGndTex);

		Device->DrawPrimitive(D3DPT_TRIANGLELIST,0,2);

		//对茶壶进行绘制,因为我们只需要对茶壶进行融合处理，所以，我们在绘制茶壶时，才启用融合处理。

        Device->SetRenderState(D3DRS_ALPHABLENDENABLE,true);	

		D3DXMatrixScaling(&W,1.5f,1.5f,1.5f);

		Device->SetTransform(D3DTS_WORLD,&W);

		Device->SetMaterial(&TeapotMtrl);

		Device->SetTexture(0,0);

		Teapot->DrawSubset(0);

		Device->SetRenderState(D3DRS_ALPHABLENDENABLE,false);
		
		Device->EndScene();

		Device->Present(0,0,0,0);

	}

	return true;
}	

//
// WndProc
//
LRESULT CALLBACK d3d::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch( msg )
	{
	case WM_DESTROY:
		::PostQuitMessage(0);
		break;
		
	case WM_KEYDOWN:
		if( wParam == VK_ESCAPE )
			::DestroyWindow(hwnd);
		break;
	}
	return ::DefWindowProc(hwnd, msg, wParam, lParam);
}

//
// WinMain
//
int WINAPI WinMain(HINSTANCE hinstance,
				   HINSTANCE prevInstance, 
				   PSTR cmdLine,
				   int showCmd)
{
	if(!d3d::InitD3D(hinstance,
		640, 480, true, D3DDEVTYPE_HAL, &Device))
	{
		::MessageBox(0, "InitD3D() - FAILED", 0, 0);
		return 0;
	}
	
	if(!Setup())
	{
		::MessageBox(0, "Setup() - FAILED", 0, 0);
		return 0;
	}
	
	d3d::EnterMsgLoop( Display );
	
	Cleanup();
	
	Device->Release();
	
	return 0;
}

我们看以下程序执行的效果：

这里我们总结一下，前面绘制的整个过程：

1，设置物体的材质。

2，创建物体，或者顶点缓存，或索引缓存，并设置顶点或者索引值。其中可能包含，顶点的颜色值，或纹理坐标，法线坐标等。

3，设置光源。

4，创建纹理。

5，设置纹理过滤方式。

6，设置Alpha的来源，并设置融合因子。

7，设置摄像机的位置，并进行取景变换，从世界坐标系到观察坐标系的变换，称为取景变换。

8，投影变换，从N维到N-1维的降维过程，称为投影变换。

9，调用Device->Clear进行清屏操作。

10，开启融合， Device->SetRenderState(D3DRS_ALPHABLENDENABLE,true);

11，

Device->BeginScene();开启绘制

D3DXMATRIX W;

D3DXMatrixIdentity(&W);

Device->SetTransform(D3DTS_WORLD,&W);世界变化，从物体坐标系到世界坐标系的变换。

Device->SetFVF(Vertex::FVF); 设置顶点格式

Device->SetStreamSource(0,BkGndQuad,0,sizeof(Vertex));设置绘制源

Device->SetMaterial(&BkGndMtrl);设置材质

Device->SetTexture(0,BkGndTex);设置纹理

Device->DrawPrimitive(D3DPT_TRIANGLELIST,0,2);进行绘制

  Device->SetRenderState(D3DRS_ALPHABLENDENABLE,false); 关闭融合

  Device->EndScene();关闭绘制

Device->Present(0,0,0,0);进行提交

每日总结：

1，Alpha融合使我们可以将当前要光栅化的图元中的像素与先前已写入后台缓存中同一位置的像素进行融合运算。

2，可通过融合因子控制源像素和目标像素的融合方式。

3，Alpha信息来源可以是所设定的材质的漫反射分量或所设定的纹理的Alpha通道。

Z18_28_19

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
DirectX 3D_实践之DirectX3D中的融合技术

身为80后的一代，作为目前社会中的中间力量，我们理所当然的应该去奋斗。我们承担着许多责任，在这许多的责任当中，我们不应该躲避，而是勇敢的承担起，每个人都应该有梦想，而且都应该为这个梦想奋勇前进，前面荆棘，坎坷，困难无数，我们不怕，只要心中有梦，像歌中唱的一样，有梦想，谁都了不起。做为30岁左右的我们，正是事业发展的黄金年龄，我们不应该害怕，应该有强大的内心，信心，去克服一切路上遇到的艰难。
复制链接

扫一扫

专栏目录