static void RenderModelDX9(bool mirror, Vector4 *pPlane)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
Matrix4x4 view_matrix;
Matrix4x4 world_matrix = g_Control.GetObjectMatrix();
if ( mirror )
{
Vector4 vEye = g_Control.GetCameraPosition();
Vector4 vUp = g_Control.m_vUp;
Vector4 vLookAt = g_Control.m_vLookAt;
Vector4 mirror_eye = MirrorPoint(vEye, *pPlane);
Vector4 mirror_lookat = MirrorPoint(vLookAt, *pPlane);
Vector4 mirror_up = MirrorPoint(vUp, *pPlane);
view_matrix = GutMatrixLookAtRH(mirror_eye, mirror_lookat, mirror_up);
g_mirror_view_matrix = view_matrix;
}
else
{
view_matrix = g_Control.GetViewMatrix();
}
device->SetTransform(D3DTS_VIEW, (D3DMATRIX *) &view_matrix);
device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &world_matrix);
g_Model_DX9.Render();
}
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// 設定要用陣列的方式傳入頂點位置跟顏色
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
// 在此不需要用到zbuffer
glDisable(GL_DEPTH_TEST);
//glDepthFunc(GL_ALWAYS);
glDepthMask(GL_FALSE);
{
// 不再用單一顏色來清除畫面,
// 把整個畫面用磚墻圖片蓋過去
// 把modelview, projection矩陣設成單位矩陣
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// 套用貼圖
glBindTexture(GL_TEXTURE_2D, g_Texture0_ID);
// 畫出矩形, 同時會清除ZBuffer
glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VT), &g_FullScreenQuad[0].m_Position);
glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex_VT), &g_FullScreenQuad[0].m_Texcoord);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// 把存放在stack中的projection取回來
glPopMatrix();
}
{
// 開啟混色功能
glEnable(GL_BLEND);
// source_blend_factor = 1
// dest_blend_factor = 1
// 混色公式= source_color * 1 + dest_color * 1
glBlendFunc(GL_ONE, GL_ONE);
// 套用貼圖
glBindTexture(GL_TEXTURE_2D, g_Texture1_ID);
// 套入轉換矩陣
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &g_proj_matrix);
Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
Matrix4x4 world_view_matrix = g_world_matrix * view_matrix;
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf( (float *) &world_view_matrix);
// 畫出矩形
glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VT), &g_Quad[0].m_Position);
glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex_VT), &g_Quad[0].m_Texcoord);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// 關閉混色功能
glDisable(GL_BLEND);
}
// 把背景backbuffer的畫面呈現出來
GutSwapBuffersOpenGL();
}
// 使用Direct3D9來繪圖
void RenderFrameDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->SetRenderState( D3DRS_LIGHTING, FALSE );
device->Clear(
0, NULL, // 清除整個畫面
D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, // 清除顏色跟Z Buffer
D3DCOLOR_ARGB(0, 0, 0, 0), // 設定要把顏色清成黑色
1.0f, // 設定要把Z值清為1, 也就是離鏡頭最遠.
0 // 設定要把Stencil buffer清為0, 在這沒差.
);
// 計算出一個可以轉換到鏡頭座標系的矩陣
Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
// 計算出一個使用非平行投影的矩陣
Matrix4x4 perspective_matrix = GutMatrixPerspectiveRH_DirectX(90.0f, 1.0f, 1.0f, 100.0f);
// 把這兩個矩陣相乘
Matrix4x4 view_perspective_matrix = view_matrix * perspective_matrix;
// 把空間中的座標點轉換到螢幕座標系上
Vector4 vertices[16];
for ( int i=0; i<16; i++ )
{
vertices[i] = g_vertices[i] * view_perspective_matrix;
vertices[i] /= vertices[i].GetW();
}
device->BeginScene(); // 開始下繪圖指令
device->SetFVF(D3DFVF_XYZ); // 設定資料格式
// 畫出金字塔的8條邊線
device->DrawPrimitiveUP(D3DPT_LINELIST, 8, vertices, sizeof(Vector4));
device->EndScene(); // 宣告所有的繪圖指令都下完了
// 把背景backbuffer的畫面呈現出來
device->Present( NULL, NULL, NULL, NULL );
}
void RenderModelDX10(bool mirror, Vector4 *pPlane)
{
ID3D10Device *pDevice = GutGetGraphicsDeviceDX10();
Matrix4x4 view_matrix;
Matrix4x4 proj_matrix;
Matrix4x4 world_matrix = g_Control.GetObjectMatrix();
if ( mirror )
{
Vector4 vEye = g_Control.GetCameraPosition();
Vector4 vUp = g_Control.m_vUp;
Vector4 vLookAt = g_Control.m_vLookAt;
Vector4 mirror_eye = MirrorPoint(vEye, *pPlane);
Vector4 mirror_lookat = MirrorPoint(vLookAt, *pPlane);
Vector4 mirror_up = MirrorPoint(vUp, *pPlane);
view_matrix = GutMatrixLookAtRH(mirror_eye, mirror_lookat, mirror_up);
g_mirror_view_matrix = view_matrix;
}
else
{
view_matrix = g_Control.GetViewMatrix();
}
// `CGutModel_DX10中有提供一些模擬Fixed Piepline的函式`
CGutModel_DX10::SetProjectionMatrix(g_proj_matrix);
CGutModel_DX10::SetViewMatrix(view_matrix);
CGutModel_DX10::SetWorldMatrix(world_matrix);
CGutModel_DX10::UpdateMatrix();
g_Model_DX10.Render();
}
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
// 清除畫面
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
// 設定要用陣列的方式傳入頂點位置跟顏色
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), g_pSphereVertices);
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_VC), g_pSphereVertices[0].m_RGBA);
// 計算出一個可以轉換到鏡頭座標系的矩陣
Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf( (float *) &view_matrix);
glDrawElements(
GL_TRIANGLES, // 指定所要畫的基本圖形種類
g_iNumSphereIndices, // 有幾個索引值
GL_UNSIGNED_SHORT, // 索引值的型態
g_pSphereIndices // 索引值陣列
);
// 把背景backbuffer的畫面呈現出來
GutSwapBuffersOpenGL();
}
// `使用Direct3D9來繪圖`
void RenderFrameDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// `消除畫面`
device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0);
// `開始下繪圖指令`
device->BeginScene();
// `計算出一個可以轉換到鏡頭座標系的矩陣`
Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
device->SetTransform(D3DTS_VIEW, (D3DMATRIX *) &view_matrix);
// `設定資料格式`
// D3DFVF_XYZ = `使用3個浮點數來記錄位置`
// D3DFVF_DIFFUSE = `使用32bits整數型態來記錄BGRA顏色`
device->SetFVF(D3DFVF_XYZ|D3DFVF_DIFFUSE);
// `太陽`
device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &g_sun_matrix);
device->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, g_iNumSphereVertices, g_iNumSphereTriangles,
g_pSphereIndices, D3DFMT_INDEX16, g_pSunVertices, sizeof(Vertex_VC) );
// `地球`
device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &g_earth_matrix);
device->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, g_iNumSphereVertices, g_iNumSphereTriangles,
g_pSphereIndices, D3DFMT_INDEX16, g_pEarthVertices, sizeof(Vertex_VC) );
// `月亮`
device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &g_moon_matrix);
device->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, g_iNumSphereVertices, g_iNumSphereTriangles,
g_pSphereIndices, D3DFMT_INDEX16, g_pMoonVertices, sizeof(Vertex_VC) );
// `宣告所有的繪圖指令都下完了`
device->EndScene();
// `把背景backbuffer的畫面呈現出來`
device->Present( NULL, NULL, NULL, NULL );
}
static void RenderModelOpenGL(bool mirror, Vector4 *pPlane)
{
Matrix4x4 view_matrix;
Matrix4x4 world_matrix = g_Control.GetObjectMatrix();
if ( mirror )
{
Vector4 vEye = g_Control.GetCameraPosition();
Vector4 vUp = g_Control.m_vUp;
Vector4 vLookAt = g_Control.m_vLookAt;
Vector4 mirror_eye = MirrorPoint(vEye, *pPlane);
Vector4 mirror_lookat = MirrorPoint(vLookAt, *pPlane);
Vector4 mirror_up = MirrorPoint(vUp, *pPlane);
view_matrix = GutMatrixLookAtRH(mirror_eye, mirror_lookat, mirror_up);
g_mirror_view_matrix = view_matrix;
}
else
{
view_matrix = g_Control.GetViewMatrix();
}
glMatrixMode(GL_MODELVIEW);
Matrix4x4 world_view_matrix = world_matrix * view_matrix;
glLoadMatrixf( (float *) &world_view_matrix);
g_Model_OpenGL.Render();
}
bool InitResourceDX9(void)
{
// `取得Direct3D9裝置`
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// `載入Pixel Shader`
g_pVertexColor_PS = GutLoadPixelShaderDX9_HLSL("../../shaders/vertex_lighting_directional.shader", "PS", "ps_2_0");
if ( g_pVertexColor_PS==NULL )
return false;
// `載入Directional Light Vertex Shader`
g_pDirLight_VS = GutLoadVertexShaderDX9_HLSL("../../shaders/vertex_lighting_directional.shader", "VS", "vs_1_1");
if ( g_pDirLight_VS==NULL )
return false;
// `載入Point Light Vertex Shader`
g_pPointLight_VS = GutLoadVertexShaderDX9_HLSL("../../shaders/vertex_lighting_point.shader", "VS", "vs_1_1");
if ( g_pPointLight_VS==NULL )
return false;
// `載入Spot Light Vertex Shader`
g_pSpotLight_VS = GutLoadVertexShaderDX9_HLSL("../../shaders/vertex_lighting_spot.shader", "VS", "vs_1_1");
if ( g_pSpotLight_VS==NULL )
return false;
// `視角轉換矩陣`
g_proj_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, 1.0f, 0.1f, 100.0f);
// `鏡頭轉換矩陣`
g_view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
// `事先把view_matrix跟proj_matrix相乘`
g_view_proj_matrix = g_view_matrix * g_proj_matrix;
// `畫出正向跟反向的三角形`
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
return true;
}
bool InitResourceOpenGL(void)
{
// 鏡頭座標系轉換矩陣
g_view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
// 設定投影矩陣
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_OpenGL(g_fFovW, 1.0f, 0.1f, 100.0f);
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &projection_matrix);
// 載入貼圖
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_TextureID = GutLoadCubemapTexture_OpenGL(texture_array);
// 使用CUBEMAP貼圖功能
glEnable(GL_TEXTURE_CUBE_MAP);
// 套用CUBEMAP貼圖
glBindTexture( GL_TEXTURE_CUBE_MAP, g_TextureID );
g_Model_OpenGL.ConvertToOpenGLModel(&g_Model);
return true;
}
bool InitResourceOpenGL(void)
{
// 計算出一個可以轉換到鏡頭座標系的矩陣
g_view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
// 設定投影矩陣
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_OpenGL(g_fFovW, 1.0f, 0.1f, 100.0f);
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &projection_matrix);
// 載入貼圖
TGAImg tga_loader;
if( IMG_OK!=tga_loader.Load("../../textures/lena_rgba.tga") )
return false;
// 產生一個貼圖物件
glGenTextures( 1, &g_TextureID );
// 使用g_TextureID貼圖物件
glBindTexture( GL_TEXTURE_2D, g_TextureID );
// RGBA模式
glTexImage2D( GL_TEXTURE_2D, 0, 3,
tga_loader.GetWidth(), tga_loader.GetHeight(), 0,
GL_RGBA, GL_UNSIGNED_BYTE, tga_loader.GetImg() );
// `設定顯示貼圖被縮小時使用線性內插`
glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR );
// `設定顯示貼圖被放大時使用線性外插`
glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR );
// 使用2D貼圖功能
glEnable(GL_TEXTURE_2D);
return true;
}
// 使用DirectX 9來繪圖
void RenderFrameDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// 消除畫面
device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0);
// 開始下繪圖指令
device->BeginScene();
// 設定座標轉換矩陣
Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
device->SetTransform(D3DTS_VIEW, (D3DMATRIX *) &view_matrix);
device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &g_world_matrix);
// 套用貼圖
device->SetTexture(0, g_pTexture);
// trilinear filter
device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
// 自動產生貼圖座標
device->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
//device->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT3);
// 使用自動normalize功能
device->SetRenderState(D3DRS_NORMALIZENORMALS, TRUE);
// 畫模型
// 傳入0代表不套用模型中的材質, 經由外部來設定.
g_Model_DX9.Render(0);
// 宣告所有的繪圖指令都下完了
device->EndScene();
// 把背景backbuffer的畫面呈現出來
device->Present( NULL, NULL, NULL, NULL );
}
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
// 清除畫面
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
// 把正向跟反向的面都畫出來
glDisable(GL_CULL_FACE);
// 使用CUBEMAP貼圖功能
glEnable(GL_TEXTURE_CUBE_MAP);
// 套用CUBEMAP貼圖
glBindTexture( GL_TEXTURE_CUBE_MAP, g_TextureID );
// 開啟自動產生貼圖座標功能
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
// 以反射的值為貼圖座標
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);
// Trilinear filter
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
// 使用自動normalize功能
glEnable(GL_NORMALIZE);
// 計算出一個可以轉換到鏡頭座標系的矩陣
Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
Matrix4x4 world_view_matrix = g_world_matrix * view_matrix;
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf( (float *) &world_view_matrix);
// 傳入0代表不套用模型中的材質, 經由外部來設定.
g_Model_OpenGL.Render(0);
// 把背景backbuffer的畫面呈現出來
GutSwapBuffersOpenGL();
}
bool InitResourceOpenGL(void)
{
// 計算出一個可以轉換到鏡頭座標系的矩陣
g_view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
// 設定投影矩陣
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_OpenGL(g_fFovW, 1.0f, 0.1f, 100.0f);
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &projection_matrix);
return true;
}
// 使用DirectX 9來繪圖
void RenderFrameDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// 開始下繪圖指令
device->BeginScene();
// 設定資料格式
device->SetFVF(D3DFVF_XYZ|D3DFVF_TEX1);
//device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0x0, 1.0f, 0);
{
Matrix4x4 IdentityMatrix;
IdentityMatrix.Identity();
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &IdentityMatrix);
device->SetTransform(D3DTS_VIEW, (D3DMATRIX *) &IdentityMatrix);
device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &IdentityMatrix);
device->SetTexture(0, g_pTexture0);
// ZBuffer測試條件設為永遠成立
device->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
// 畫出矩形, 同時會清除ZBuffer
device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, g_FullScreenQuad, sizeof(Vertex_VT));
// ZBuffer測試條件設為小於
device->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESS);
}
{
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &g_projection_matrix);
// 鏡頭座標系轉換矩陣
Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
device->SetTransform(D3DTS_VIEW, (D3DMATRIX *) &view_matrix);
device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &g_world_matrix);
device->SetTexture(0, g_pTexture1);
// 開啟混色功能
device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
// source_blend_factor = 1
device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
// dest_blend_factor = 1
device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
// 混色公式 = source_color * 1 + dest_color * 1
// 畫出矩形
device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, g_Quad, sizeof(Vertex_VT));
// 關閉Alpha Test功能
device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
}
// 宣告所有的繪圖指令都下完了
device->EndScene();
// 把背景backbuffer的畫面呈現出來
device->Present( NULL, NULL, NULL, NULL );
}
bool InitResourceOpenGL(void)
{
// 計算出一個可以轉換到鏡頭座標系的矩陣
g_view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
// 投影矩陣
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_OpenGL(60.0f, 1.0f, 1.0f, 100.0f);
// 設定視角轉換矩陣
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &projection_matrix);
//glShadeModel(GL_FLAT); // 關閉內插
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // 使用晝邊線模式
glEnable(GL_CULL_FACE); // 忽略背對鏡頭的面
return true;
}
bool InitResourceDX9(void)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// 設定視角轉換矩陣
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, 1.0f, 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_CULLMODE, D3DCULL_NONE);
return true;
}
void ResizeWindowDX9(int width, int height)
{
GutResetGraphicsDeviceDX9();
// 投影矩陣, 重設水平跟垂直方向的視角.
float aspect = (float) height / (float) width;
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, 0.1f, 100.0f);
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
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_CULLMODE, D3DCULL_NONE);
}
void CGutUserControl::SetCamera(Vector4 &vEye, Vector4 &vLookAt, Vector4 &vUp)
{
m_vEye = vEye;
m_vLookAt = vLookAt;
m_vUp = vUp;
m_eUP = UP_CUSTOMIZED;
m_ViewMatrix = GutMatrixLookAtRH(m_vEye, m_vLookAt, m_vUp);
m_CameraMatrix = m_ViewMatrix;
m_CameraMatrix.FastInvert();
m_RefCameraMatrix = m_CameraMatrix;
m_RefCameraMatrix[3].Set(0.0f, 0.0f, 0.0f, 1.0f);
}
bool InitResourceDX9(void)
{
// `取得Direct3D9裝置`
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// `計算出一個可以轉換到鏡頭座標系的矩陣`
Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_DirectX(60.0f, 1.0f, 1.0f, 100.0f);
// `設定視角轉換矩陣`
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &projection_matrix);
// `設定鏡頭轉換矩陣`
device->SetTransform(D3DTS_VIEW, (D3DMATRIX *) &view_matrix);
// `關閉打光`
device->SetRenderState(D3DRS_LIGHTING, FALSE);
return true;
}
bool InitResourceOpenGL(void)
{
// 計算出一個可以轉換到鏡頭座標系的矩陣
g_view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
// 設定投影矩陣
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_OpenGL(g_fFovW, 1.0f, 0.1f, 100.0f);
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &projection_matrix);
g_TextureID = GutLoadTexture_OpenGL("../../textures/lena.dds");
// 設定顯示貼圖時使用線性內插
glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR );
// 設定顯示貼圖時使用線性外插
glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR );
// 使用2D貼圖功能
glEnable(GL_TEXTURE_2D);
return true;
}
// 使用DirectX9來繪圖
void RenderFrameDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
D3DMATRIX pMatrix[3]={0};
device->GetTransform(D3DTS_WORLD , &pMatrix[0] );
device->GetTransform(D3DTS_VIEW , &pMatrix[1] );
device->GetTransform(D3DTS_PROJECTION , &pMatrix[2] );
//D3DXMatrixOrthoLH(&matProject, width, height, Znear, Zfar);
device->SetRenderState( D3DRS_LIGHTING, FALSE );
device->Clear(
0, NULL, // 清除整個畫面
D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, // 清除顏色跟Z Buffer
D3DCOLOR_ARGB(0, 0, 0, 0), // 設定要把顏色清成黑色
1.0f, // 設定要把Z值清為1, 也就是離鏡頭最遠.
0 // 設定要把Stencil buffer清為0, 在這沒差.
);
// 計算出一個可以轉換到鏡頭座標系的矩陣
Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
// 設定鏡頭轉換矩陣
// 因為記憶體排列方法相同, 可以直接把Matrix4x4轉型成D3DMATRIX.
device->SetTransform(D3DTS_VIEW, (D3DMATRIX *) &view_matrix);
// 計算出一個使用非平行投影的矩陣
Matrix4x4 perspective_matrix = GutMatrixPerspectiveRH_DirectX(90.0f, 1.0f, 1.0f, 100.0f);
// 設定視角轉換矩陣
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *)&perspective_matrix);
// 開始下繪圖指令
device->BeginScene();
// 設定資料格式
device->SetFVF(D3DFVF_XYZ);
// 畫出金字塔的8條邊線
device->DrawPrimitiveUP(D3DPT_LINELIST, 8, g_vertices, sizeof(Vector4));
// 宣告所有的繪圖指令都下完了
device->EndScene();
// 呈現出背景backbuffer的畫面
device->Present( NULL, NULL, NULL, NULL );
}
static void RenderModelDX9(bool mirror, Vector4 *pPlane)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
Matrix4x4 view_matrix;
if ( mirror )
{
Vector4 vEye = g_Control.GetCameraPosition();
Vector4 vLookAt = g_Control.m_vLookAt;
Vector4 vUp = g_Control.m_vUp;
Vector4 mirror_eye = MirrorPoint(vEye, *pPlane);
Vector4 mirror_lookat = MirrorPoint(vLookAt, *pPlane);
Vector4 mirror_up = MirrorVector(vUp, *pPlane);
Matrix4x4 temp_matrix = GutMatrixLookAtRH(mirror_eye, mirror_lookat, mirror_up);
// 因為是鏡射, 在轉換到鏡頭座標系後要做個左右對調的動作.
Matrix4x4 mirror_x;
mirror_x.Identity();
mirror_x.Scale(-1.0f, 1.0f, 1.0f);
view_matrix = temp_matrix * mirror_x;
// 右左對調後, 3角形的頂點排列順序會被反過來.
GutSetDX9BackFace(D3DCULL_CCW);
}
else
{
view_matrix = g_Control.GetViewMatrix();
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
GutSetDX9BackFace(D3DCULL_CW);
}
Matrix4x4 world_matrix = g_Control.GetObjectMatrix();
device->SetTransform(D3DTS_VIEW, (D3DMATRIX *) &view_matrix);
device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &world_matrix);
g_Model_DX9.Render();
GutSetDX9BackFace(D3DCULL_CW);
}
bool InitResourceOpenGL(void)
{
// 計算出一個可以轉換到鏡頭座標系的矩陣
g_view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
// 設定投影矩陣
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_OpenGL(g_fFovW, 1.0f, 0.1f, 100.0f);
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &projection_matrix);
// 載入貼圖
TGAImg tga_loader;
if( IMG_OK!=tga_loader.Load("../../textures/checkerboard.tga") )
return false;
// 產生一個貼圖物件
glGenTextures( 1, &g_TextureID );
// 使用g_TextureID貼圖物件
glBindTexture( GL_TEXTURE_2D, g_TextureID );
// RGBA模式
GLuint format = GL_RGBA;
switch(tga_loader.GetBPP())
{
case 8:
format = GL_LUMINANCE;
break;
case 24:
format = GL_RGB;
break;
case 32:
format = GL_RGBA;
break;
}
glTexImage2D( GL_TEXTURE_2D, 0, 3,
tga_loader.GetWidth(), tga_loader.GetHeight(), 0,
format, GL_UNSIGNED_BYTE, tga_loader.GetImg() );
// 設定顯示貼圖時使用線性內插
glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR );
// 設定顯示貼圖時使用線性外插
glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR );
// 使用2D貼圖功能
glEnable(GL_TEXTURE_2D);
return true;
}
bool InitResourceOpenGL(void)
{
// 計算出一個可以轉換到鏡頭座標系的矩陣
g_view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
// 投影矩陣
g_projection_matrix = GutMatrixPerspectiveRH_OpenGL(90.0f, 1.0f, 0.1f, 100.0f);
// 設定視角轉換矩陣
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &g_projection_matrix);
glMatrixMode(GL_MODELVIEW);
glEnable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
g_models[0].ConvertToOpenGLModel(&g_sun_model);
g_models[1].ConvertToOpenGLModel(&g_earth_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);
// 鏡頭座標系的轉換矩陣
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);
}
static void RenderModelOpenGL(bool mirror, Vector4 *pPlane)
{
Matrix4x4 view_matrix;
if ( mirror )
{
Vector4 vEye = g_Control.GetCameraPosition();
Vector4 vLookAt = g_Control.m_vLookAt;
Vector4 vUp = g_Control.m_vUp;
Vector4 mirror_eye = MirrorPoint(vEye, *pPlane);
Vector4 mirror_lookat = MirrorPoint(vLookAt, *pPlane);
Vector4 mirror_up = MirrorVector(vUp, *pPlane);
Matrix4x4 temp_matrix = GutMatrixLookAtRH(mirror_eye, mirror_lookat, mirror_up);
// 因為是鏡射, 在轉換到鏡頭座標系後要做個左右對調的動作.
Matrix4x4 mirror_x;
mirror_x.Identity();
mirror_x.Scale(-1.0f, 1.0f, 1.0f);
view_matrix = temp_matrix * mirror_x;
g_mirror_view_matrix = view_matrix;
// 右左對調後, 3角形的頂點排列順序會被反過來.
glFrontFace(GL_CW);
}
else
{
view_matrix = g_Control.GetViewMatrix();
glFrontFace(GL_CCW);
}
glMatrixMode(GL_MODELVIEW);
Matrix4x4 world_view_matrix = g_Control.GetObjectMatrix() * view_matrix;
glLoadMatrixf( (float *) &world_view_matrix);
g_Model_OpenGL.Render();
glFrontFace(GL_CCW);
}
// `使用OpenGL來繪圖`
void RenderFrameOpenGL(void)
{
// `清除畫面`
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
// `把正向跟反向的面都畫出來`
glDisable(GL_CULL_FACE);
// `設定要用陣列的方式傳入頂點位置跟顏色`
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
// `計算出一個可以轉換到鏡頭座標系的矩陣`
Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
Matrix4x4 world_view_matrix = g_world_matrix * view_matrix;
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf( (float *) &world_view_matrix);
GLint modes[] = {
GL_REPEAT, // `左下角`
GL_MIRRORED_REPEAT, // `左上角`
GL_CLAMP_TO_EDGE, // `右下角`
GL_CLAMP_TO_BORDER, // `右上角`
};
float border_color[4] = {0.5f, 0.5f, 0.5f, 0.5f};
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
for ( int i=0; i<4; i++ )
{
glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VT), g_Quads[i][0].m_Position);
glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex_VT), g_Quads[i][0].m_Texcoord);
// `套用不同的貼圖座標解讀模式`
// GL_TEXTURE_WRAP_S `設定水平方向解讀模式`
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, modes[i]);
// GL_TEXTURE_WRAP_T `設定垂直方向解讀模式`
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, modes[i]);
// `畫出格子`
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
// `把背景backbuffer的畫面呈現出來`
GutSwapBuffersOpenGL();
}
bool InitResourceDX9(void)
{
// 取得Direct3D 9裝置
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// 計算出一個可以轉換到鏡頭座標系的矩陣
Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_DirectX(90.0f, 1.0f, 1.0f, 100.0f);
// 設定視角轉換矩陣
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &projection_matrix);
// 設定鏡頭轉換矩陣
device->SetTransform(D3DTS_VIEW, (D3DMATRIX *) &view_matrix);
// 關閉打光
device->SetRenderState(D3DRS_LIGHTING, FALSE);
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
//device->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_FLAT); // 關閉內插
//device->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME); // 使用畫邊線模式
return true;
}
static void RenderSolarSystemOpenGL(void)
{
Vector4 eye(0.0f, 0.0f, 15.0f);
Vector4 lookat(0.0f, 0.0f, 0.0f);
Vector4 up(0.0f, 1.0f, 0.0f);
// `設定要用陣列的方式傳入頂點位置跟顏色`
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
// `計算出一個可以轉換到鏡頭座標系的矩陣`
Matrix4x4 projection_matrix = GutMatrixPerspectiveRH_OpenGL(60.0f, 1.0f, 0.1f, 100.0f);
glMatrixMode(GL_PROJECTION);
glLoadMatrixf( (float *) &projection_matrix);
Matrix4x4 view_matrix = GutMatrixLookAtRH(eye, lookat, up);
Matrix4x4 world_view_matrix;
glMatrixMode(GL_MODELVIEW);
glDisable(GL_TEXTURE_2D);
// `太陽`
world_view_matrix = g_sun_matrix * view_matrix;
glLoadMatrixf( (float *) &world_view_matrix);
glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), g_pSunVertices);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_VC), g_pSunVertices[0].m_RGBA);
glDrawElements(GL_TRIANGLES, g_iNumSphereIndices, GL_UNSIGNED_SHORT, g_pSphereIndices);
// `地球`
world_view_matrix = g_earth_matrix * view_matrix;
glLoadMatrixf( (float *) &world_view_matrix);
glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), g_pEarthVertices);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_VC), g_pEarthVertices[0].m_RGBA);
glDrawElements(GL_TRIANGLES, g_iNumSphereIndices, GL_UNSIGNED_SHORT, g_pSphereIndices);
// `月球`
world_view_matrix = g_moon_matrix * view_matrix;
glLoadMatrixf( (float *) &world_view_matrix);
glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), g_pMoonVertices);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_VC), g_pMoonVertices[0].m_RGBA);
glDrawElements(GL_TRIANGLES, g_iNumSphereIndices, GL_UNSIGNED_SHORT, g_pSphereIndices);
}
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);
// 鏡頭座標系的轉換矩陣
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);
// 載入貼圖
g_pTexture = GutLoadTexture_DX9("../../textures/lena_rgba.tga");
return true;
}
