bool InitResourceDX9(void)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// 設定視角轉換矩陣
int w, h;
GutGetWindowSize(w, h);
float aspect = (float) h / (float) w;
g_projection_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, 0.1f, 100.0f);
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &g_projection_matrix);
// 畫出正向跟反向的三角形
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
CGutModel::SetTexturePath("../../textures/");
for ( int t=0; t<MAX_NUM_TEXTURES; t++ )
{
// trilinear filter
device->SetSamplerState(t, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(t, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(t, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
}
g_Model_DX9.ConvertToDX9Model(&g_Model);
return true;
}
void ResizeWindowDX9(int width, int height)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// Reset Device
GutResetGraphicsDeviceDX9();
// 設定視角轉換矩陣
int w, h;
GutGetWindowSize(w, h);
float aspect = (float) h / (float) w;
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, 0.1f, 100.0f);
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &projection_matrix);
// 關閉打光
device->SetRenderState(D3DRS_LIGHTING, FALSE);
// 畫出正向跟反向的三角形
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
// trilinear
device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
// trilinear
device->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
}
// 使用DirectX 9來繪圖
void RenderFrameDX9(void)
{
// 取得視窗大小
int w, h;
GutGetWindowSize(w, h);
// 清除畫面
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(100, 100, 100, 255), 1.0f, 0);
// 開始下繪圖指令
device->BeginScene();
// view matrix
Matrix4x4 view_matrix = g_Control.GetViewMatrix();
Matrix4x4 object_matrix = g_Control.GetObjectMatrix();
g_view_matrix = object_matrix * view_matrix;
device->SetTransform(D3DTS_VIEW, (D3DMATRIX *)&g_view_matrix);
// projection matrix
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *)&g_projection_matrix);
// render objects
RenderSolarSystemDX9();
// 宣告所有的繪圖指令都下完了
device->EndScene();
// 把背景backbuffer的畫面呈現出來
device->Present( NULL, NULL, NULL, NULL );
}
void InitStateDX9(void)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// 關閉打光
device->SetRenderState(D3DRS_LIGHTING, FALSE);
// 使用trilinear
device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
//
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
//
device->SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, FALSE);
device->GetRenderTarget(0, &g_pMainFrameBuffer);
device->GetDepthStencilSurface(&g_pMainDepthBuffer);
int width, height;
GutGetWindowSize(width, height);
g_iFrameBufferWidth = width * 2;
g_iFrameBufferHeight = height * 2;
device->CreateTexture(g_iFrameBufferWidth, g_iFrameBufferHeight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &g_pTexture, NULL);
device->CreateDepthStencilSurface(g_iFrameBufferWidth, g_iFrameBufferHeight, D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0, FALSE, &g_pDepthStencil, NULL);
g_pTexture->GetSurfaceLevel(0, &g_pFrameBuffer);
}
bool InitResourceDX9(void)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// 設定視角轉換矩陣
int w, h;
GutGetWindowSize(w, h);
float aspect = (float) h / (float) w;
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, 0.1f, 100.0f);
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &projection_matrix);
// 關閉打光
device->SetRenderState(D3DRS_LIGHTING, FALSE);
// 畫出正向跟反向的三角形
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
// 載入貼圖
g_pTexture = GutLoadTexture_DX9("../../textures/lena_rgb.tga");
if ( NULL==g_pTexture )
return false;
// trilinear
device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
return true;
}
void RenderFrameDX10(void)
{
int w, h;
GutGetWindowSize(w, h);
Vector4 vClearColor(0.0f, 0.0f, 0.0f, 0.0f);
UINT stride = sizeof(Vertex_VT);
UINT offset = 0;
ID3D10RenderTargetView *pRenderTargetView = GutGetDX10RenderTargetView(); //frame buffer
ID3D10DepthStencilView *pDepthStencilView = GutGetDX10DepthStencilView(); //depth/stencil buffer
D3D10_VIEWPORT vp = {0, 0, w, h, 0.0f, 1.0f};
g_pDevice->RSSetViewports(1, &vp);
g_pDevice->OMSetRenderTargets(1, &pRenderTargetView, NULL);
// 設定Shader
g_pDevice->VSSetShader(g_pBlurVS);
g_pDevice->PSSetShader(g_pRGBAPixelShader);
// 設定vertex shader讀取參數的記憶體位罝
g_pDevice->VSSetConstantBuffers(0, 1, &g_pVSConstantBuffer);
// 設定vertex資料格式
g_pDevice->IASetInputLayout(g_pVertexLayout);
// 設定三角形頂點索引值資料排列是triangle strip
g_pDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
g_pDevice->PSSetShaderResources(0, 1, &g_pTexture);
g_pDevice->IASetVertexBuffers(0, 1, &g_pVertexBuffer, &stride, &offset);
g_pDevice->Draw(4, 0);
if ( g_bPosteffect )
{
ID3D10ShaderResourceView *pRSView = NULL;
pRSView = BrightnessImage(g_pTexture, &g_ImageInfo);
pRSView = BlurImage(pRSView, &g_ImageInfo);
g_pDevice->OMSetRenderTargets(1, &pRenderTargetView, NULL);
g_pDevice->RSSetViewports(1, &vp);
float dummy[] = {0,0,0,0};
g_pDevice->OMSetBlendState(g_pAddBlend, dummy, 0xffffffff);
// 設定Shader
g_pDevice->VSSetShader(g_pBlurVS);
g_pDevice->PSSetShader(g_pRGBAPixelShader);
// 設定vertex shader讀取參數的記憶體位罝
g_pDevice->VSSetConstantBuffers(0, 1, &g_pVSConstantBuffer);
// 設定vertex資料格式
g_pDevice->IASetInputLayout(g_pVertexLayout);
// 設定三角形頂點索引值資料排列是triangle strip
g_pDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
g_pDevice->PSSetShaderResources(0, 1, &pRSView);
g_pDevice->IASetVertexBuffers(0, 1, &g_pVertexBuffer, &stride, &offset);
g_pDevice->Draw(4, 0);
g_pDevice->OMSetBlendState(g_pNoBlend, dummy, 0xffffffff);
}
// 等待硬體掃結束, 然後才更新畫面
IDXGISwapChain *pSwapChain = GutGetDX10SwapChain();
pSwapChain->Present(1, 0);
}
bool ReInitResourceDX10(void)
{
int w, h;
GutGetWindowSize(w, h);
g_ViewportSize[0].width = w;
g_ViewportSize[0].height = h;
for ( int i=0; i<NUM_FRAMEBUFFERS; i++ )
{
SAFE_RELEASE(g_pTextures[i]);
SAFE_RELEASE(g_pSRView[i]);
SAFE_RELEASE(g_pRTView[i]);
}
for ( int i=0; i<NUM_FRAMEBUFFERS; i++ )
{
if ( !GutCreateRenderTarget_DX10(
g_ViewportSize[i].width, g_ViewportSize[i].height,
DXGI_FORMAT_R16G16B16A16_FLOAT, &g_pTextures[i], &g_pSRView[i], &g_pRTView[i]) )
return false;
}
float aspect = (float)h/(float)w;
g_proj_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, g_fNearZ, g_fFarZ);
return true;
}
bool ReInitResourceDX10(void)
{
int w, h;
GutGetWindowSize(w, h);
float aspect = (float)h/(float)w;
g_proj_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, g_fNearZ, g_fFarZ);
return true;
}
void ResizeWindowDX9(int width, int height)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// Reset Device
GutResetGraphicsDeviceDX9();
// 設定視角轉換矩陣
int w, h;
GutGetWindowSize(w, h);
float aspect = (float) h / (float) w;
g_projection_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, 0.1f, 100.0f);
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &g_projection_matrix);
}
bool ReInitResourceDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->SetRenderState(D3DRS_LIGHTING, FALSE);
int w, h;
GutGetWindowSize(w, h);
float aspect = (float)h/(float)w;
g_proj_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, g_fNearZ, g_fFarZ);
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *)&g_proj_matrix);
return true;
}
bool ReInitResourceDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
int w,h;
GutGetWindowSize(w, h);
float fAspect = (float)h/(float)w;
g_proj_matrix = GutMatrixPerspectiveRH_DirectX(g_fFOV, fAspect, g_fCameraNearZ, g_fCameraFarZ);
g_ImageInfo.m_iWidth = g_texture_width;
g_ImageInfo.m_iHeight = g_texture_height;
g_ImageInfo.m_bProcedure = true;
//D3DFORMAT fmt = D3DFMT_A16B16G16R16F;
D3DFORMAT fmt = D3DFMT_A32B32G32R32F;
for ( int i=0; i<TEX_TEXTURES; i++ )
{
device->CreateTexture(
g_texture_width, g_texture_height,
1, D3DUSAGE_RENDERTARGET,
fmt, D3DPOOL_DEFAULT,
&g_pTextures[i], NULL);
if ( NULL==g_pTextures[i] ) return false;
g_pTextures[i]->GetSurfaceLevel(0, &g_pSurfaces[i]);
if ( NULL==g_pSurfaces[i] ) return false;
}
device->GetRenderTarget(0, &g_pMainFramebuffer);
device->GetDepthStencilSurface(&g_pMainDepthbuffer);
device->SetRenderTarget(0, g_pSurfaces[0]);
device->SetRenderTarget(1, g_pSurfaces[1]);
device->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_RGBA(0, 0, 0, 0), 1.0f, 0);
device->SetRenderTarget(0, g_pMainFramebuffer);
device->SetRenderTarget(1, NULL);
return true;
}
static void RenderParticle(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
int w, h; GutGetWindowSize(w, h);
Matrix4x4 wvp_matrix = g_Control.GetObjectMatrix() * g_Control.GetViewMatrix() * g_proj_matrix;
Vector4 ScreenSize( (float)w, (float)h, 0.0f, 0.0f);
float fTanW = FastMath::Tan( FastMath::DegToRad(g_fFOV) );
device->SetRenderTarget(0, g_pMainFramebuffer);
device->SetDepthStencilSurface(g_pMainDepthbuffer);
device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 0x0, 1.0f, 0);
D3DXHANDLE shader = g_pParticleRenderFX->GetTechniqueByName("RenderParticle");
D3DXHANDLE positiontex_var = g_pParticleRenderFX->GetParameterByName(NULL, "PositionTex");
D3DXHANDLE velocitytex_var = g_pParticleRenderFX->GetParameterByName(NULL, "VelocityTex");
D3DXHANDLE wvp_matrix_var = g_pParticleRenderFX->GetParameterByName(NULL, "wvp_matrix");
D3DXHANDLE tan_fov_var = g_pParticleRenderFX->GetParameterByName(NULL, "fTanW");
D3DXHANDLE screensize_var = g_pParticleRenderFX->GetParameterByName(NULL, "ScreenSize");
D3DXHANDLE diffusetex_var = g_pParticleRenderFX->GetParameterByName(NULL, "DiffuseTex");
g_pParticleRenderFX->SetTechnique(shader);
g_pParticleRenderFX->SetTexture(positiontex_var, g_pTextures[TEX_POSITION1]);
g_pParticleRenderFX->SetTexture(velocitytex_var, g_pTextures[TEX_VELOCITY1]);
g_pParticleRenderFX->SetMatrix(wvp_matrix_var, (D3DXMATRIX*)&wvp_matrix);
g_pParticleRenderFX->SetVector(screensize_var, (D3DXVECTOR4*)&ScreenSize);
g_pParticleRenderFX->SetFloat(tan_fov_var, fTanW);
g_pParticleRenderFX->SetTexture(diffusetex_var, g_pParticleTexture);
int num_processed_particles = (g_num_particles / g_texture_width) * g_texture_width;
if ( num_processed_particles )
{
device->SetFVF(D3DFVF_TEX1);
g_pParticleRenderFX->Begin(NULL,0);
g_pParticleRenderFX->BeginPass(0);
//device->SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE);
device->DrawPrimitiveUP(D3DPT_POINTLIST, num_processed_particles, g_pParticleArray, sizeof(sParticle));
//device->SetRenderState(D3DRS_POINTSPRITEENABLE, FALSE);
g_pParticleRenderFX->EndPass();
g_pParticleRenderFX->End();
}
}
void RenderFrameDX10(void)
{
Vector4 vClearColor(0.0f, 0.0f, 0.0f, 0.0f);
UINT stride = sizeof(Vertex_VT);
UINT offset = 0;
// 取得呼叫GutCreateGraphicsDeviceDX10時所產生的D3D10物件
ID3D10RenderTargetView *pRenderTargetView = GutGetDX10RenderTargetView(); //frame buffer
ID3D10DepthStencilView *pDepthStencilView = GutGetDX10DepthStencilView(); //depth/stencil buffer
IDXGISwapChain *pSwapChain = GutGetDX10SwapChain(); // front/back buffer
int w, h;
GutGetWindowSize(w, h);
D3D10_RECT rect = {0, 0, w, h/2};
g_pDevice->RSSetScissorRects(1, &rect);
// 清除顏色
g_pDevice->ClearRenderTargetView(pRenderTargetView, (float *)&vClearColor);
// 清除Depth/Stencil buffer
g_pDevice->ClearDepthStencilView(pDepthStencilView, D3D10_CLEAR_DEPTH | D3D10_CLEAR_STENCIL, 1.0f, 0);
// 設定vertex shader
g_pDevice->VSSetShader(g_pVertexShader);
// 設定pixel shader
g_pDevice->PSSetShader(g_pPixelShader);
// 設定vertex shader讀取參數的記憶體位罝
g_pDevice->VSSetConstantBuffers(0, 1, &g_pConstantBuffer);
// 套用貼圖
g_pDevice->PSSetShaderResources(0, 1, &g_pTexture);
// 設定vertex資料格式
g_pDevice->IASetInputLayout(g_pVertexLayout);
// 設定vertex buffer
g_pDevice->IASetVertexBuffers(0, 1, &g_pVertexBuffer, &stride, &offset);
// 設定三角形頂點索引值資料排列是triangle strip
g_pDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
// 計算矩陣
Matrix4x4 view_proj_matrix = g_view_matrix * g_proj_matrix;
Matrix4x4 world_view_proj_matrix = g_world_matrix * view_proj_matrix;
// 更新shader參數
Matrix4x4 *pConstData;
g_pConstantBuffer->Map( D3D10_MAP_WRITE_DISCARD, NULL, (void **) &pConstData );
*pConstData = world_view_proj_matrix;
g_pConstantBuffer->Unmap();
// 畫出格子
g_pDevice->Draw(4, 0);
// 等待硬體掃結束, 然後才更新畫面
pSwapChain->Present(1, 0);
}
bool InitResourceDX9(void)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// 設定視角轉換矩陣
int w, h;
GutGetWindowSize(w, h);
float aspect = (float) h / (float) w;
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, 0.1f, 100.0f);
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &projection_matrix);
// 關閉打光
device->SetRenderState(D3DRS_LIGHTING, FALSE);
// 畫出正向跟反向的三角形
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
// 載入貼圖
g_pTexture = GutLoadTexture_DX9("../../textures/checkerboard.tga");
return true;
}
// `使用OpenGL來繪圖`
void RenderFrameOpenGL(void)
{
{
// `使用`g_framebuffer framebuffer object
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, g_framebuffer);
glViewport(0, 0, 512, 512);
// `清除畫面`
glClearColor(0.4f, 0.4f, 0.4f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//
RenderSolarSystemOpenGL();
}
{
// `使用主framebuffer object, 也就是視窗.`
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
int w, h;
GutGetWindowSize(w, h);
glViewport(0, 0, w, h);
//` 清除畫面`
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// `計算出一個可以轉換到鏡頭座標系的矩陣`
Matrix4x4 view_matrix = g_Control.GetViewMatrix();
Matrix4x4 world_matrix = g_Control.GetObjectMatrix();
Matrix4x4 world_view_matrix = world_matrix * view_matrix;
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf( (float *) &world_view_matrix);
// `設定頂點資料格式`
glEnableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, g_texture);
glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VT), g_Quad_Inv[0].m_Position);
glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex_VT), g_Quad_Inv[0].m_Texcoord);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
// `把背景backbuffer的畫面呈現出來`
GutSwapBuffersOpenGL();
}
void ResizeWindowDX9(int width, int height)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// Reset Device
GutResetGraphicsDeviceDX9();
// 設定視角轉換矩陣
int w, h;
GutGetWindowSize(w, h);
float aspect = (float) h / (float) w;
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, 0.1f, 100.0f);
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &projection_matrix);
// 鏡頭座標系的轉換矩陣
Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
device->SetTransform(D3DTS_VIEW, (D3DMATRIX *) &view_matrix);
// 關閉打光
device->SetRenderState(D3DRS_LIGHTING, FALSE);
// 畫出正向跟反向的三角形
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
}
bool InitResourceDX9(void)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// 設定視角轉換矩陣
int w, h;
GutGetWindowSize(w, h);
float aspect = (float) h / (float) w;
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, 0.1f, 100.0f);
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &projection_matrix);
// 關閉打光
device->SetRenderState(D3DRS_LIGHTING, FALSE);
// 畫出正向跟反向的三角形
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
// 載入貼圖
const char *texture_array[] = {
"../../textures/uffizi_right.tga",
"../../textures/uffizi_left.tga",
"../../textures/uffizi_top.tga",
"../../textures/uffizi_bottom.tga",
"../../textures/uffizi_back.tga", // `右手座標系上 Z+ 為鏡頭後方.`
"../../textures/uffizi_front.tga" // `右手座標系上 Z- 為鏡頭前方.`
};
g_pTexture = GutLoadCubemapTexture_DX9(texture_array);
if ( g_pTexture==NULL )
{
// 有些舊硬體不支援 mipmapped cubemap , 改載入 dds 的版本.
g_pTexture = GutLoadCubemapTexture_DX9("../../textures/uffizi_cubemap.dds");
if ( g_pTexture==NULL )
return false;
}
if ( !g_Model_DX9.ConvertToDX9Model(&g_Model) )
return false;
return true;
}
void ResizeWindowDX9(int width, int height)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// Reset Device
GutResetGraphicsDeviceDX9();
// 設定視角轉換矩陣
int w, h;
GutGetWindowSize(w, h);
float aspect = (float) h / (float) w;
g_projection_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, g_fNear, g_fFar);
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &g_projection_matrix);
device->SetRenderState(D3DRS_NORMALIZENORMALS, TRUE);
device->SetRenderState(D3DRS_SPECULARENABLE, TRUE);
device->SetRenderState(D3DRS_COLORVERTEX, FALSE);
device->SetRenderState(D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL);
device->SetRenderState(D3DRS_SPECULARMATERIALSOURCE, D3DMCS_MATERIAL);
device->SetRenderState(D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_MATERIAL);
device->SetRenderState(D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL);
}
bool InitResourceDX9(void)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// 設定視角轉換矩陣
int w, h;
GutGetWindowSize(w, h);
float aspect = (float) h / (float) w;
g_projection_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, g_fNear, g_fFar);
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &g_projection_matrix);
for ( int t=0; t<MAX_NUM_TEXTURES; t++ )
{
// trilinear filter
device->SetSamplerState(t, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(t, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(t, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
}
g_Model_DX9.ConvertToDX9Model(&g_Model);
//g_Model_DX9.SetCullMode(D3DCULL_NONE);
device->SetRenderState(D3DRS_NORMALIZENORMALS, TRUE);
device->SetRenderState(D3DRS_SPECULARENABLE, TRUE);
device->SetRenderState(D3DRS_COLORVERTEX, FALSE);
device->SetRenderState(D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL);
device->SetRenderState(D3DRS_SPECULARMATERIALSOURCE, D3DMCS_MATERIAL);
device->SetRenderState(D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_MATERIAL);
device->SetRenderState(D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL);
device->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
//device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
return true;
}
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
Vector4 vPlane(0.0f, 0.0f, 1.0f, -g_mirror_z);
{
// 使用g_framebuffer framebuffer object
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, g_framebuffer);
glViewport(0, 0, 512, 512);
// 清除畫面
glClearColor(0.0f, 0.0f, 0.9f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//
RenderModelOpenGL(true, &vPlane);
}
{
// 使用主framebuffer object, 也就是視窗.
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
int w, h;
GutGetWindowSize(w, h);
glViewport(0, 0, w, h);
// 清除畫面
glClearColor(0.0f, 0.0f, 0.6f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
RenderModelOpenGL(false, NULL);
// 設定轉換矩陣
Matrix4x4 world_view_matrix = g_Control.GetViewMatrix();
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &g_projection_matrix);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf( (float *) &world_view_matrix);
sModelMaterial_OpenGL material;
material.m_Textures[0] = g_texture;
material.Submit(NULL);
// 設定頂點資料格式
glEnableClientState(GL_VERTEX_ARRAY);
glClientActiveTexture(GL_TEXTURE0_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
// 計算貼圖座標矩陣
Matrix4x4 uv_offset_matrix;
uv_offset_matrix.Scale_Replace(0.5f, 0.5f, 1.0f);
uv_offset_matrix[3].Set(0.5f, 0.5f, 0.0f, 1.0f);
Matrix4x4 texture_matrix = g_mirror_view_matrix * g_projection_matrix * uv_offset_matrix;
glMatrixMode(GL_TEXTURE);
glLoadMatrixf( (float *) &texture_matrix );
// vertex position & texcoord使用同樣的資料
glVertexPointer(3, GL_FLOAT, sizeof(Vertex_V), &g_Quad[0].m_Position);
glTexCoordPointer(3, GL_FLOAT, sizeof(Vertex_V), &g_Quad[0].m_Position);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glLoadIdentity();
}
// 把背景backbuffer的畫面呈現出來
GutSwapBuffersOpenGL();
}
// 使用Direct3D9來繪圖
void RenderFrameDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
Vector4 vPlane(0.0f, 0.0f, 1.0f, -g_mirror_z);
device->BeginScene();
// 消除畫面
device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, D3DCOLOR_RGBA(0, 0, 150, 255), 1.0f, 0);
// 畫出茶壼
RenderModelDX9(false, NULL);
// 畫出鏡面, 同時把stencil值設為1.
{
device->SetRenderState(D3DRS_STENCILENABLE, TRUE);
device->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE);
device->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS);
device->SetRenderState(D3DRS_STENCILREF, 1);
Matrix4x4 identity_matrix = Matrix4x4::IdentityMatrix();
device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &identity_matrix);
sModelMaterial_DX9 material;
material.m_Material.Diffuse.r = material.m_Material.Diffuse.g = material.m_Material.Diffuse.b = material.m_Material.Diffuse.a = 0.0f;
material.Submit();
// 畫出鏡面
device->SetFVF(D3DFVF_XYZ);
device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, g_Quad_v, sizeof(Vertex_V));
}
// 把鏡面范圍的ZBuffer清為1.0
{
// 設定stencil test條件, 只更新鏡面范圍的像素.
device->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_EQUAL);
device->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
device->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS); // 關閉z test
device->SetRenderState(D3DRS_COLORWRITEENABLE, 0); // 關閉RGBA的輸出
// 經由修改viewport Z范圍的方法, 把3D物件的Z值輸出固定為1.
int w, h;
GutGetWindowSize(w, h);
D3DVIEWPORT9 viewport;
viewport.X = viewport.Y = 0;
viewport.Width = w; viewport.Height = h;
viewport.MinZ = 1.0f; viewport.MaxZ = 1.0f;
device->SetViewport(&viewport);
// 畫出鏡面
device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, g_Quad_v, sizeof(Vertex_V));
// 把Z值范圍還原成0-1
viewport.MinZ = 0.0f; viewport.MaxZ = 1.0f;
device->SetViewport(&viewport);
// 還原zbuffer test的測試條件
device->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
// 重新打開RGBA的輸出
device->SetRenderState(D3DRS_COLORWRITEENABLE,
D3DCOLORWRITEENABLE_RED |
D3DCOLORWRITEENABLE_GREEN |
D3DCOLORWRITEENABLE_BLUE |
D3DCOLORWRITEENABLE_ALPHA);
}
// 在鏡面范圍里畫出鏡射的茶壼
{
RenderModelDX9(true, &vPlane);
device->SetRenderState(D3DRS_STENCILENABLE, FALSE);
}
// 宣告所有的繪圖指令都下完了
device->EndScene();
// 把背景backbuffer的畫面呈現出來
device->Present( NULL, NULL, NULL, NULL );
}
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
// `取得視窗大小`
int w, h;
GutGetWindowSize(w, h);
// `清除畫面`
glClearColor(0.4f, 0.4f, 0.4f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Vector4 camera_lookat(0.0f, 0.0f, 0.0f);
Matrix4x4 ortho_proj = GutMatrixOrthoRH_OpenGL(20.0f, 20.0f, 0.1f, 100.0f);
{
// `前視圖`
glViewport(0, h/2, w/2, h/2);
// view matrix
Vector4 camera_pos(0.0f, -20.0f, 0.0f);
Vector4 camera_up(0.0f, 0.0f, 1.0f);
g_view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&ortho_proj[0][0]);
// render objects
RenderSolarSystemOpenGL();
}
{
// `上視圖`
glViewport(w/2, h/2, w/2, h/2);
// view matrix
Vector4 camera_pos(0.0f, 0.0f, 20.0f);
Vector4 camera_up(0.0f, 1.0f, 0.0f);
g_view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&ortho_proj[0][0]);
// render objects
RenderSolarSystemOpenGL();
}
{
// `右視圖`
glViewport(0, 0, w/2, h/2);
// view matrix
Vector4 camera_pos(20.0f, 0.0f, 0.0f);
Vector4 camera_up(0.0f, 0.0f, 1.0f);
g_view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&ortho_proj[0][0]);
// render objects
RenderSolarSystemOpenGL();
}
{
// `使用者視角`
glViewport(w/2, 0, w/2, h/2);
// object * view matrix
Matrix4x4 object_matrix = g_Control.GetObjectMatrix();
Matrix4x4 view_matrix = g_Control.GetViewMatrix();
g_view_matrix = object_matrix * view_matrix;
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&g_projection_matrix[0][0]);
// render objects
RenderSolarSystemOpenGL();
}
{
// `畫出viewport的邊界`
glViewport(0, 0, w, h);
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
glEnableClientState(GL_VERTEX_ARRAY);
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// worldview matrix
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// `畫邊界`
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), g_Border);
glDrawArrays(GL_LINES, 0, 4);
glPopClientAttrib();
}
// `把背景backbuffer的畫面呈現出來`
GutSwapBuffersOpenGL();
}
// `使用OpenGL來繪圖`
void RenderFrameOpenGL(void)
{
// `取得視窗大小`
int w, h;
GutGetWindowSize(w, h);
// `清除畫面`
glClearColor(0.4f, 0.4f, 0.4f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// `在螢幕上畫出行星運動`
RenderSolarSystemOpenGL(false);
/*
`啟動Selection Buffer, 硬體會試著去重畫一次3D物件,`
`但不會更新畫面, 只會記錄下落在畫面中某個范圍內所有3D物件.`
*/
int x,y,buttons[3];
GutGetMouseState(x, y, buttons);
if ( buttons[0] )
{
GLint viewport[4];
glSelectBuffer(BUFSIZE,selectBuf);
glRenderMode(GL_SELECT);
glInitNames();
glGetIntegerv(GL_VIEWPORT,viewport);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
// `設定Selection Buffer的檢查范圍`
gluPickMatrix(x, viewport[3]-y, 3, 3, viewport);
float fRatio = (viewport[2]+0.0) / viewport[3];
glMultMatrixf( (float *)&g_projection_matrix );
// `在Selection Buffer中畫出3D物件`
RenderSolarSystemOpenGL(true);
int hits = glRenderMode(GL_RENDER);
GLuint *ptr = selectBuf;
GLuint Zmin = 0xffffffff;
GLuint SelectedObject = 0;
// `找出檢查范圍中, 距離鏡頭最近的物體.`
for ( int i=0; i<hits; i++, ptr+=4 )
{
if ( ptr[1] < Zmin )
{
Zmin = ptr[1];
SelectedObject = ptr[3];
}
}
switch(SelectedObject)
{
default:
case 0:
printf("Nothing\r");
break;
case 1:
printf("Sun \r");
break;
case 2:
printf("Earth \r");
break;
}
glMatrixMode(GL_PROJECTION);
glPopMatrix();
}
// `把背景backbuffer的畫面呈現出來`
GutSwapBuffersOpenGL();
}
bool InitResourceDX9(void)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// 設定視角轉換矩陣
int w, h;
GutGetWindowSize(w, h);
float aspect = (float) h / (float) w;
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, 0.1f, 100.0f);
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &projection_matrix);
// 關閉打光
device->SetRenderState(D3DRS_LIGHTING, FALSE);
// 畫出正向跟反向的三角形
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
// 載入貼圖
TGAImg tga_loader;
if( IMG_OK!=tga_loader.Load("../../textures/checkerboard.tga") )
return false;
int bytes_per_pixel = tga_loader.GetBPP()/8;
// 產生貼圖物件
if ( D3D_OK!=device->CreateTexture(tga_loader.GetWidth(), tga_loader.GetHeight(),
1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &g_pTexture, NULL) )
return false;
int image_size = tga_loader.GetWidth() * tga_loader.GetHeight() * 4;
// 拷具貼圖資料
D3DLOCKED_RECT locked_rect;
g_pTexture->LockRect(0, &locked_rect, NULL, 0);
unsigned char *target = (unsigned char *)locked_rect.pBits;
unsigned char *source = tga_loader.GetImg();
for ( int y=0; y<tga_loader.GetHeight(); y++ )
{
for ( int x=0; x<tga_loader.GetWidth(); x++ )
{
switch(bytes_per_pixel)
{
case 1:
target[0] = source[0];
target[1] = source[0];
target[2] = source[0];
target[3] = source[0];
source++;
break;
case 3:
target[0] = source[2];
target[1] = source[1];
target[2] = source[0];
target[3] = 255;
source +=3;
break;
case 4:
target[0] = source[2];
target[1] = source[1];
target[2] = source[0];
target[3] = source[3];
source +=4;
break;
}
target+=4;
}
}
g_pTexture->UnlockRect(0);
return true;
}
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
Matrix4x4 light_projection_matrix;
Matrix4x4 light_view_matrix;
Matrix4x4 light_world_view_matrix;
Matrix4x4 view_matrix = g_Control.GetViewMatrix();
Matrix4x4 world_matrix = g_Control.GetObjectMatrix();
GLuint blurred_texture = 0;
{
// 使用g_framebuffer framebuffer object
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, g_framebuffer);
glViewport(0, 0, g_framebuffer_w, g_framebuffer_h);
// 清除畫面
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// 設定光源位置
Vector4 vLightPos = g_Light.m_Position;
Vector4 vLightUp(0.0f, 1.0f, 0.0f);
Vector4 vLightLookat(0.0f, 0.0f, 0.0f);
light_projection_matrix = GutMatrixPerspectiveRH_OpenGL(60.0f, 1.0f, 0.1f, 100.0f);
light_view_matrix = GutMatrixLookAtRH(vLightPos, vLightLookat, vLightUp);
light_world_view_matrix = world_matrix * light_view_matrix;
// 把鏡頭放到光源位置來畫陰影
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &light_projection_matrix );
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf( (float *) &light_world_view_matrix );
SetupLightingOpenGL();
// 套用預設材質, 把貼圖全部關閉
sModelMaterial_OpenGL material;
material.m_Ambient = Vector4::GetZero();
material.m_Emissive = Vector4::GetZero();
material.m_Diffuse = Vector4::GetZero();
material.m_Specular = Vector4::GetZero();
material.m_bCullFace = false;
material.Submit(NULL);
// 畫出模型
g_Model_OpenGL.Render(0);
}
// 把影子柔化
{
blurred_texture = BlurTexture(g_texture);
}
{
// 使用主framebuffer object, 也就是視窗.
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
int w, h;
GutGetWindowSize(w, h);
glViewport(0, 0, w, h);
// 清除畫面
glClearColor(0.0f, 0.0f, 0.6f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf( (float *) &view_matrix);
// 設定光源
SetupLightingOpenGL();
// 設定轉換矩陣
Matrix4x4 world_view_matrix = world_matrix * view_matrix;
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &g_projection_matrix);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf( (float *) &world_view_matrix);
// 畫出茶壼
g_Model_OpenGL.Render();
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf( (float *) &view_matrix);
sModelMaterial_OpenGL material;
material.m_Textures[0] = blurred_texture;
material.Submit(NULL);
// 計算貼圖矩陣
Matrix4x4 uv_offset_matrix;
uv_offset_matrix.Identity();
uv_offset_matrix.Scale(0.5f, 0.5f, 0.5f);
uv_offset_matrix[3].Set(0.5f, 0.5f, 0.5f, 1.0f);
Matrix4x4 texture_matrix = light_view_matrix * light_projection_matrix * uv_offset_matrix;
glMatrixMode(GL_TEXTURE);
glLoadMatrixf( (float *)&texture_matrix);
// 開啟自動產生貼圖座標功能
// S/T/R分別代表貼圖座標的X/Y/Z軸
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
// 以光線的反射向量來做為貼圖座標
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
Matrix4x4 identMatrix = Matrix4x4::IdentityMatrix();
glTexGenfv(GL_S, GL_OBJECT_PLANE, &identMatrix[0][0]);
glTexGenfv(GL_T, GL_OBJECT_PLANE, &identMatrix[1][0]);
glTexGenfv(GL_R, GL_OBJECT_PLANE, &identMatrix[2][0]);
// 畫出地表
g_Terrain_OpenGL.Render(0);
glLoadIdentity();
}
// 把背景backbuffer的畫面呈現出來
GutSwapBuffersOpenGL();
}
bool ReInitResourceDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
GutGetWindowSize(g_iWidth, g_iHeight);
g_proj_matrix = GutMatrixOrthoRH_DirectX(g_iWidth, g_iHeight, 0.0f, 100.0f);
int w = g_iWidth;
int h = g_iHeight;
g_ImageInfo.m_iWidth = g_iWidth;
g_ImageInfo.m_iHeight = g_iHeight;
g_ImageInfo.m_bProcedure = true;
//D3DFORMAT fmt = D3DFMT_G16R16;
D3DFORMAT fmt = D3DFMT_A8R8G8B8;
device->SetRenderState(D3DRS_LIGHTING, FALSE);
device->CreateTexture(
w, h,
1, D3DUSAGE_RENDERTARGET,
fmt, D3DPOOL_DEFAULT,
&g_pTextures[TEX_HEIGHT0], NULL);
if ( NULL==g_pTextures[TEX_HEIGHT0] ) return false;
g_pTextures[TEX_HEIGHT0]->GetSurfaceLevel(0, &g_pSurfaces[TEX_HEIGHT0]);
if ( NULL==g_pSurfaces[TEX_HEIGHT0] ) return false;
device->CreateTexture(
w, h,
1, D3DUSAGE_RENDERTARGET,
fmt, D3DPOOL_DEFAULT,
&g_pTextures[TEX_HEIGHT1], NULL);
if ( NULL==g_pTextures[TEX_HEIGHT1] ) return false;
if ( NULL==g_pTextures[TEX_HEIGHT1] ) return false;
g_pTextures[TEX_HEIGHT1]->GetSurfaceLevel(0, &g_pSurfaces[TEX_HEIGHT1]);
device->CreateTexture(
w, h,
1, D3DUSAGE_RENDERTARGET,
fmt, D3DPOOL_DEFAULT,
&g_pTextures[TEX_HEIGHT2], NULL);
if ( NULL==g_pTextures[TEX_HEIGHT2] ) return false;
g_pTextures[TEX_HEIGHT2]->GetSurfaceLevel(0, &g_pSurfaces[TEX_HEIGHT2]);
if ( NULL==g_pSurfaces[TEX_HEIGHT2] ) return false;
device->CreateTexture(
w, h,
1, D3DUSAGE_RENDERTARGET,
D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT,
&g_pTextures[TEX_NORMAL], NULL);
if ( NULL==g_pTextures[TEX_NORMAL] ) return false;
g_pTextures[TEX_NORMAL]->GetSurfaceLevel(0, &g_pSurfaces[TEX_NORMAL]);
if ( NULL==g_pSurfaces[TEX_NORMAL] ) return false;
device->GetRenderTarget(0, &g_pMainFramebuffer);
device->GetDepthStencilSurface(&g_pMainDepthbuffer);
device->SetRenderTarget(0, g_pSurfaces[0]);
device->SetRenderTarget(1, g_pSurfaces[1]);
device->SetRenderTarget(2, g_pSurfaces[2]);
device->Clear(0, NULL, D3DCLEAR_TARGET, 0x0, 1.0f, 0);
device->SetRenderTarget(0, g_pMainFramebuffer);
device->SetRenderTarget(1, NULL);
device->SetRenderTarget(2, NULL);
device->SetRenderState(D3DRS_NORMALIZENORMALS, TRUE);
device->SetRenderState(D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL);
device->SetRenderState(D3DRS_SPECULARMATERIALSOURCE, D3DMCS_MATERIAL);
return true;
}
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
Matrix4x4 light_projection_matrix;
Matrix4x4 light_view_matrix;
Matrix4x4 light_world_view_matrix;
Matrix4x4 view_matrix = g_Control.GetViewMatrix();
Matrix4x4 world_matrix = g_Control.GetObjectMatrix();
{
// `使用` g_framebuffer framebuffer object
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, g_framebuffer);
glViewport(0, 0, 512, 512);
// `清除畫面`
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// `光源位置`
Vector4 vLightPos = g_Light.m_Position;
Vector4 vLightUp(0.0f, 1.0f, 0.0f);
Vector4 vLightLookat(0.0f, 0.0f, 0.0f);
// `設定光源的轉換矩陣`
light_projection_matrix = GutMatrixPerspectiveRH_OpenGL(60.0f, 1.0f, 0.1f, 100.0f);
light_view_matrix = GutMatrixLookAtRH(vLightPos, vLightLookat, vLightUp);
light_world_view_matrix = world_matrix * light_view_matrix;
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &light_projection_matrix );
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf( (float *) &light_world_view_matrix );
glDisable(GL_LIGHTING);
// `畫出黑色的茶壼`
sModelMaterial_OpenGL material;
material.m_bCullFace = false;
material.m_Diffuse.Set(0.0);
material.Submit(NULL);
g_Model_OpenGL.Render(0);
}
{
// `使用主framebuffer object, 也就是視窗.`
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
int w, h;
GutGetWindowSize(w, h);
glViewport(0, 0, w, h);
// `清除畫面`
glClearColor(0.0f, 0.0f, 0.6f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// `計算出一個可以轉換到鏡頭座標系的矩陣`
Matrix4x4 view_matrix = g_Control.GetViewMatrix();
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf( (float *) &view_matrix);
SetupLightingOpenGL();
Matrix4x4 world_view_matrix = world_matrix * view_matrix;
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &g_projection_matrix);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf( (float *) &world_view_matrix);
g_Model_OpenGL.Render();
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf( (float *) &view_matrix);
glDisable(GL_LIGHTING);
sModelMaterial_OpenGL material;
material.m_Diffuse.Set(1.0f);
material.m_Textures[0] = g_texture;
material.Submit(NULL);
Matrix4x4 uv_offset_matrix;
uv_offset_matrix.Identity();
uv_offset_matrix.Scale(0.5f, 0.5f, 0.5f);
uv_offset_matrix[3].Set(0.5f, 0.5f, 0.5f, 1.0f);
Matrix4x4 texture_matrix = light_view_matrix * light_projection_matrix * uv_offset_matrix;
glMatrixMode(GL_TEXTURE);
glLoadMatrixf( (float *)&texture_matrix);
glDisable(GL_LIGHTING);
// `設定頂點資料格式`
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
glEnableClientState(GL_VERTEX_ARRAY);
glClientActiveTexture(GL_TEXTURE0_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
//
glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VT), &g_Quad[0].m_Position);
// `直接把頂點資料拿來當貼圖座標使用`
glTexCoordPointer(4, GL_FLOAT, sizeof(Vertex_VT), &g_Quad[0].m_Position);
// `畫出看板`
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glPopClientAttrib();
glLoadIdentity();
}
// 把背景backbuffer的畫面呈現出來
GutSwapBuffersOpenGL();
}
void RenderFrameDX10(void)
{
Vector4 vClearColor(0.4f, 0.4f, 0.4f, 1.0f);
// frame buffer
ID3D10RenderTargetView *pRenderTargetView = GutGetDX10RenderTargetView();
// depth/stencil buffer
ID3D10DepthStencilView *pDepthStencilView = GutGetDX10DepthStencilView();
// front/back buffer
IDXGISwapChain *pSwapChain = GutGetDX10SwapChain();
// `清除顏色`
g_pDevice->ClearRenderTargetView(pRenderTargetView, (float *)&vClearColor);
// `清除`Depth/Stencil buffer
g_pDevice->ClearDepthStencilView(pDepthStencilView, D3D10_CLEAR_DEPTH | D3D10_CLEAR_STENCIL, 1.0f, 0);
Vector4 camera_lookat(0.0f, 0.0f, 0.0f);
int w, h;
GutGetWindowSize(w, h);
Matrix4x4 view_matrix;
Matrix4x4 ortho_proj = GutMatrixOrthoRH_DirectX(20.0f, 20.0f, 0.1f, 100.0f);
// `前視圖`
{
D3D10_VIEWPORT vp = {0, 0, w/2, h/2, 0.0f, 1.0f};
g_pDevice->RSSetViewports(1, &vp);
// view matrix
Vector4 camera_pos(0.0f, -20.0f, 0.0f);
Vector4 camera_up(0.0f, 0.0f, 1.0f);
view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// render objects
RenderSolarSystemDX10(view_matrix, ortho_proj);
}
// `上視圖`
{
D3D10_VIEWPORT vp = {w/2, 0, w/2, h/2, 0.0f, 1.0f};
g_pDevice->RSSetViewports(1, &vp);
// view matrix
Vector4 camera_pos(0.0f, 0.0f, 20.0f);
Vector4 camera_up(0.0f, 1.0f, 0.0f);
view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// render objects
RenderSolarSystemDX10(view_matrix, ortho_proj);
}
// `右視圖`
{
D3D10_VIEWPORT vp = {0, h/2, w/2, h/2, 0.0f, 1.0f};
g_pDevice->RSSetViewports(1, &vp);
// view matrix
Vector4 camera_pos(20.0f, 0.0f, 0.0f);
Vector4 camera_up(0.0f, 0.0f, 1.0f);
view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// render objects
RenderSolarSystemDX10(view_matrix, ortho_proj);
}
// `使用者視角`
{
D3D10_VIEWPORT vp = {w/2, h/2, w/2, h/2, 0.0f, 1.0f};
g_pDevice->RSSetViewports(1, &vp);
// view matrix
Matrix4x4 view_matrix = g_Control.GetViewMatrix();
Matrix4x4 object_matrix = g_Control.GetObjectMatrix();
view_matrix = object_matrix * view_matrix;
// render objects
RenderSolarSystemDX10(view_matrix, g_proj_matrix);
}
// `畫邊線`
{
UINT stride = sizeof(Vertex_VC);
UINT offset = 0;
D3D10_VIEWPORT vp = {0, 0, w, h, 0.0f, 1.0f};
g_pDevice->RSSetViewports(1, &vp);
// `設定`vertex shader
g_pDevice->VSSetShader(g_pVertexShader);
// `設定`pixel shader
g_pDevice->PSSetShader(g_pPixelShader);
// `設定vertex shader讀取參數的記憶體位置`
g_pDevice->VSSetConstantBuffers(0, 1, &g_pConstantBuffer);
Matrix4x4 *pConstData;
g_pConstantBuffer->Map( D3D10_MAP_WRITE_DISCARD, NULL, (void **) &pConstData );
pConstData->Identity();
g_pConstantBuffer->Unmap();
g_pDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_LINELIST);
g_pDevice->IASetVertexBuffers(0, 1, &g_pBorderVertexBuffer, &stride, &offset);
g_pDevice->Draw(4, 0);
}
// `等待硬體掃結束, 然後才更新畫面.`
pSwapChain->Present(1, 0);
}
bool ReInitResourceDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->SetRenderState(D3DRS_LIGHTING, FALSE);
int w, h;
GutGetWindowSize(w, h);
g_ImageInfo.m_iWidth = w;
g_ImageInfo.m_iHeight = h;
float aspect = (float)h/(float)w;
g_proj_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, g_fNearZ, g_fFarZ);
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *)&g_proj_matrix);
int width = w;
int height = h;
D3DFORMAT fmt = D3DFMT_A16B16G16R16F;
device->CreateTexture(width, height, 1,
D3DUSAGE_RENDERTARGET, fmt,
D3DPOOL_DEFAULT, &g_pFrameBuffer[FULLSIZE], NULL);
device->CreateTexture(256, 256, 1,
D3DUSAGE_RENDERTARGET, fmt,
D3DPOOL_DEFAULT, &g_pFrameBuffer[DOWNSAMPLED_256x256], NULL);
device->CreateTexture(64, 64, 1,
D3DUSAGE_RENDERTARGET, fmt,
D3DPOOL_DEFAULT, &g_pFrameBuffer[DOWNSAMPLED_64x64], NULL);
device->CreateTexture(16, 16, 1,
D3DUSAGE_RENDERTARGET, fmt,
D3DPOOL_DEFAULT, &g_pFrameBuffer[DOWNSAMPLED_16x16], NULL);
device->CreateTexture(4, 4, 1,
D3DUSAGE_RENDERTARGET, fmt,
D3DPOOL_DEFAULT, &g_pFrameBuffer[DOWNSAMPLED_4x4], NULL);
device->CreateTexture(1, 1, 1,
D3DUSAGE_RENDERTARGET, fmt,
D3DPOOL_DEFAULT, &g_pFrameBuffer[LUMINANCE_PREVIOUS], NULL);
device->CreateTexture(1, 1, 1,
D3DUSAGE_RENDERTARGET, fmt,
D3DPOOL_DEFAULT, &g_pFrameBuffer[LUMINANCE_CURRENT], NULL);
device->CreateTexture(1, 1, 1,
D3DUSAGE_RENDERTARGET, fmt,
D3DPOOL_DEFAULT, &g_pFrameBuffer[LUMINANCE_TEMP], NULL);
for ( int i=0; i<NUM_FRAMEBUFFERS; i++ )
{
if ( g_pFrameBuffer[i]==NULL )
return false;
g_pFrameBuffer[i]->GetSurfaceLevel(0, &g_pFrameSurface[i]);
}
for ( int i=0; i<4; i++ )
{
device->SetSamplerState(i, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(i, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(i, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(i, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
device->SetSamplerState(i, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
}
device->GetRenderTarget(0, &g_pMainSurface); g_pMainSurface->Release();
device->GetDepthStencilSurface(&g_pDepthStencilSurface); g_pDepthStencilSurface->Release();
return true;
}
