介绍RenderTexture,RenderSurface和SetRenderTarget

转载

#include < D3DX9.h >
#include < string >
typedef std:: string String;
#define SAFE_RELEASE(o) {if(o){o->Release();o = 0;}}

LPDIRECT3D9 g_pD3D = 0 ; // D3D Driver
LPDIRECT3DDEVICE9 g_pd3dDevice = 0 ; // D3D 设备
D3DCAPS9 g_Caps = {(D3DDEVTYPE) 0 } ; // D3D 的帽子
LPD3DXMESH g_pMeshTeapot = 0 ; // 茶壶顶点缓冲区
LPDIRECT3DVERTEXBUFFER9 g_pVB = 0 ; // 顶点缓冲区
LPDIRECT3DINDEXBUFFER9 g_pIB = 0 ; // 索引缓冲区
LPDIRECT3DTEXTURE9 g_pTexture = 0 ; // 贴图
LPDIRECT3DTEXTURE9 g_pRenderTexture = 0 ; // 渲染到贴图
LPDIRECT3DSURFACE9 g_pRenderSurface = 0 ; // 渲染到贴图的表面
// 顶点定义
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1)
struct CUSTOMVERTEX
{
D3DXVECTOR3 position;
D3DCOLOR color;
float u , v;
} ;

// 错误记录
void D3DErr(String strMsg)
{
MessageBox( 0 , strMsg.c_str() , " 错误 " , MB_OK);
}

// 初始化顶点缓冲区
HRESULT InitVB()
{
// 创建茶壶
if (FAILED(D3DXCreateTeapot(g_pd3dDevice , & g_pMeshTeapot , 0 )))
return E_FAIL;
// 创建顶点缓冲区
if (FAILED(g_pd3dDevice -> CreateVertexBuffer( 4 * sizeof (CUSTOMVERTEX) , 0 , D3DFVF_CUSTOMVERTEX , D3DPOOL_DEFAULT , & g_pVB , 0 )))
return E_FAIL;

CUSTOMVERTEX * pVertecies;
// 锁定缓冲区
if (SUCCEEDED(g_pVB -> Lock( 0 , 0 , ( void ** ) & pVertecies , 0 )))
{
pVertecies[ 0 ].position = D3DXVECTOR3( - 1 , 1 , 0 );
pVertecies[ 1 ].position = D3DXVECTOR3( - 1 , - 1 , 0 );
pVertecies[ 2 ].position = D3DXVECTOR3( 1 , 1 , 0 );
pVertecies[ 3 ].position = D3DXVECTOR3( 1 , - 1 , 0 );

pVertecies[ 0 ].u = 0 ;
pVertecies[ 0 ].v = 0 ;

pVertecies[ 1 ].u = 0 ;
pVertecies[ 1 ].v = 1 ;

pVertecies[ 2 ].u = 1 ;
pVertecies[ 2 ].v = 0 ;

pVertecies[ 3 ].u = 1 ;
pVertecies[ 3 ].v = 1 ;

pVertecies[ 0 ].color = 0xFFFFFFFF ;
pVertecies[ 1 ].color = 0xFFFFFFFF ;
pVertecies[ 2 ].color = 0xFFFFFFFF ;
pVertecies[ 3 ].color = 0xFFFFFFFF ;
g_pVB -> Unlock();
}
else
{
return E_FAIL;
}

// 载入纹理
if (FAILED(D3DXCreateTextureFromFile(g_pd3dDevice , " ..//BRICE.JPG " , & g_pTexture)))
{
D3DErr( " 无法载入纹理Brice.jpg " );
return E_FAIL;
}

// 创建渲染到贴图的表面
if (FAILED(g_pd3dDevice -> CreateTexture( 512 , 512 , 1 , D3DUSAGE_RENDERTARGET , D3DFMT_A8R8G8B8 , D3DPOOL_DEFAULT , & g_pRenderTexture , 0 )))
{
D3DErr( " 无法创建渲染贴图 " );
return E_FAIL;
}
// 获取贴图的渲染表面
if (FAILED(g_pRenderTexture -> GetSurfaceLevel( 0 , & g_pRenderSurface)))
{
return E_FAIL;
}
return S_OK;
}

// 初始化模型
HRESULT InitGeometry()
{
// 创建顶点缓冲区
if (FAILED(InitVB()))
return E_FAIL;
return S_OK;
}

// 设置矩阵变换
void SetTransform()
{

// 世界变换
D3DXMATRIX matWorld;
D3DXMatrixIdentity( & matWorld);
// 设置世界矩阵
g_pd3dDevice -> SetTransform(D3DTS_WORLD , & matWorld);
// Set up our view matrix. A view matrix can be defined given an eye point,
// a point to lookat, and a direction for which way is up. Here, we set the
// eye five units back along the z-axis and up three units, look at the
// origin, and define "up" to be in the y-direction.
// 视口变换
D3DXMATRIX matView;
D3DXMatrixLookAtLH( & matView , & D3DXVECTOR3( 0 , 0 , - 5 )
, & D3DXVECTOR3( 0 , 0 , 0 )
, & D3DXVECTOR3( 0 , 1 , 0 ));
g_pd3dDevice -> SetTransform(D3DTS_VIEW , & matView);
// For the projection matrix, we set up a perspective transform (which
// transforms geometry from 3D view space to 2D viewport space, with
// a perspective divide making objects smaller in the distance). To build
// a perpsective transform, we need the field of view (1/4 pi is common),
// the aspect ratio, and the near and far clipping planes (which define at
// what distances geometry should be no longer be rendered).
D3DXMATRIXA16 matProj;
D3DXMatrixPerspectiveFovLH( & matProj, D3DX_PI / 4 , 800.0f / 600.0f , 1.0f , 100.0f );
g_pd3dDevice -> SetTransform( D3DTS_PROJECTION, & matProj );

}

// 渲染场景
void Render()
{
if (g_pd3dDevice)
{
LPDIRECT3DSURFACE9 pRenderTarget;
// 保存渲染表面
g_pd3dDevice -> GetRenderTarget( 0 , & pRenderTarget);
// 设置我们的贴图表面
g_pd3dDevice -> SetRenderTarget( 0 , g_pRenderSurface);
// 清空场景，渲染到贴图的背景是蓝色的
g_pd3dDevice -> Clear( 0 , 0 , D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER , D3DCOLOR_XRGB( 0 , 0 , 0xFF ) , 1 , 0 );
// 开始渲染到贴图
if (SUCCEEDED(g_pd3dDevice -> BeginScene()))
{
// 设置通常的矩阵
SetTransform();
D3DXMATRIX matWorld;
// 旋转茶壶
D3DXMatrixRotationAxis( & matWorld , & D3DXVECTOR3( 1 , 0 , 1 ) , D3DX_PI * 2.0f * (timeGetTime() % 5000 ) / 5000.0f );
g_pd3dDevice -> SetTransform(D3DTS_WORLD , & matWorld);

// 设置渲染到表面的投影矩阵（这里可有可无，因为我们的窗口创建是512×512的）
D3DXMATRIXA16 matProj;
D3DXMatrixPerspectiveFovLH( & matProj, D3DX_PI / 4 , 1.0f , 1.0f , 100.0f );
g_pd3dDevice -> SetTransform( D3DTS_PROJECTION, & matProj );

// 设置贴图
g_pd3dDevice -> SetTexture( 0 , g_pTexture);
g_pd3dDevice -> SetSamplerState( 0 , D3DSAMP_ADDRESSU , D3DTADDRESS_MIRROR);
g_pd3dDevice -> SetSamplerState( 0 , D3DSAMP_ADDRESSV , D3DTADDRESS_MIRROR);
// 自动生成纹理坐标
g_pd3dDevice -> SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
g_pd3dDevice -> SetTextureStageState( 0 , D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_SPHEREMAP);
g_pd3dDevice -> SetRenderState(D3DRS_LIGHTING , FALSE);
// 渲染茶壶
g_pMeshTeapot -> DrawSubset( 0 );
g_pd3dDevice -> EndScene();
}

// 恢复渲染表面为显示器
g_pd3dDevice -> SetRenderTarget( 0 , pRenderTarget);

// 清空场景，真实场景是红色背景的
g_pd3dDevice -> Clear( 0 , 0 , D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER , D3DCOLOR_XRGB( 0xFF , 0xFF , 0 ) , 1 , 0 );
// 开始渲染真实场景
if (SUCCEEDED(g_pd3dDevice -> BeginScene()))
{
SetTransform();
D3DXMATRIX matWorld;
// 旋转表面
D3DXMatrixRotationAxis( & matWorld , & D3DXVECTOR3( 1 , 1 , 0 ) , sinf(D3DX_PI * 2.0f * (timeGetTime() % 5000 ) / 5000.0f ));
// 设置世界矩阵
g_pd3dDevice -> SetTransform(D3DTS_WORLD , & matWorld);
// 设置已经渲染到表面的贴图
g_pd3dDevice -> SetTexture( 0 , g_pRenderTexture);
g_pd3dDevice -> SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
g_pd3dDevice -> SetTextureStageState( 0 , D3DTSS_TEXCOORDINDEX, 0 );

g_pd3dDevice -> SetSamplerState( 0 , D3DSAMP_ADDRESSU , D3DTADDRESS_MIRROR);
g_pd3dDevice -> SetSamplerState( 0 , D3DSAMP_ADDRESSV , D3DTADDRESS_MIRROR);
g_pd3dDevice -> SetRenderState(D3DRS_LIGHTING , FALSE);
// g_pd3dDevice->SetRenderState(D3DRS_FILLMODE , D3DFILL_WIREFRAME);
g_pd3dDevice -> SetStreamSource( 0 , g_pVB , 0 , sizeof (CUSTOMVERTEX));
g_pd3dDevice -> SetFVF(D3DFVF_CUSTOMVERTEX);
g_pd3dDevice -> DrawPrimitive(D3DPT_TRIANGLESTRIP , 0 , 2 );
g_pd3dDevice -> EndScene();
}
// 显示
g_pd3dDevice -> Present( 0 , 0 , 0 , 0 );
}
}

// 初始化 D3D 设备
HRESULT InitD3D(HWND hWnd)
{
// 创建 D3D Driver
if (NULL == (g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)))
{
D3DErr( " 无法创建Direct3D9设备 " );
return E_FAIL;
}
// 获取当前显示模式
D3DDISPLAYMODE d3ddm;
if (FAILED(g_pD3D -> GetAdapterDisplayMode(D3DADAPTER_DEFAULT , & d3ddm)))
{
D3DErr( " 无法获取D3D显示器模式 " );
return E_FAIL;
}

RECT rect;
::GetClientRect(hWnd , & rect);

// 填充参数
D3DPRESENT_PARAMETERS d3dpp;
memset( & d3dpp , 0 , sizeof (d3dpp));
d3dpp.BackBufferFormat = d3ddm.Format;
d3dpp.BackBufferWidth = rect.right;
d3dpp.BackBufferHeight = rect.bottom;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.Windowed = true ;
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
d3dpp.EnableAutoDepthStencil = TRUE;

// 获取帽子
if (FAILED(g_pD3D -> GetDeviceCaps(D3DADAPTER_DEFAULT , D3DDEVTYPE_HAL , & g_Caps)))
{
D3DErr( " 获取D3D 帽子时发生错误 " );
return E_FAIL;
}

// 创建D3D设备
if (FAILED(g_pD3D -> CreateDevice(D3DADAPTER_DEFAULT
, D3DDEVTYPE_HAL
, hWnd
// 检查是否支持硬件顶点处理
, g_Caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT ? D3DCREATE_HARDWARE_VERTEXPROCESSING : D3DCREATE_SOFTWARE_VERTEXPROCESSING
, & d3dpp
, & g_pd3dDevice
)
))
{
D3DErr( " 创建D3D设备时发生错误 " );
return E_FAIL;
}
g_pd3dDevice -> SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
g_pd3dDevice -> SetRenderState( D3DRS_ZENABLE, TRUE );

if (FAILED(InitGeometry()))
return E_FAIL;
return S_OK;
}

// 清空所有占用的资源
void CleanUp()
{
SAFE_RELEASE(g_pTexture);
SAFE_RELEASE(g_pIB);
SAFE_RELEASE(g_pVB);
SAFE_RELEASE(g_pd3dDevice);
SAFE_RELEASE(g_pD3D);
}

// 消息处理
LRESULT WINAPI MsgProc(HWND hWnd , UINT message , WPARAM wParam , LPARAM lParam)
{
switch (message)
{
case WM_DESTROY:
CleanUp();
PostQuitMessage( 0 );
break ;
}
return ::DefWindowProc(hWnd, message , wParam , lParam);
}

// Windows 入口
int WINAPI WinMain(IN HINSTANCE hInstance, IN HINSTANCE hPrevInstance, IN LPSTR lpCmdLine, IN int nShowCmd )
{
WNDCLASS wndClass;
memset( & wndClass , 0 , sizeof (wndClass));
wndClass.hInstance = hInstance;
wndClass.lpszClassName = " 渲染到纹理 " ;
wndClass.lpfnWndProc = MsgProc;
RegisterClass( & wndClass);

// 创建窗口
HWND hWnd = CreateWindow( " 渲染到纹理 " , " 渲染到纹理！ "
, 0 , 0 , 0 , 640 , 480 , GetDesktopWindow()
, 0 , wndClass.hInstance , 0 );
// 显示窗口
ShowWindow(hWnd , SW_SHOWDEFAULT);
UpdateWindow(hWnd);

// 初始化 D3D 设备
if (SUCCEEDED(InitD3D(hWnd)))
{
// 消息处理循环
MSG msg;
memset( & msg , 0 , sizeof (msg));
while (msg.message != WM_QUIT)
{
if (PeekMessage( & msg , 0 , 0 , 0 , PM_REMOVE))
{
TranslateMessage( & msg);
DispatchMessage( & msg);
}
else
{
Render();
}
}
}
// 清空场景
CleanUp();

UnregisterClass( " 渲染到纹理 " , wndClass.hInstance);

return 0 ;
}