示例#1
0
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
	// 清除畫面
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	// 設定好GPU要去哪讀取頂點資料
	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(4, GL_FLOAT, sizeof(Vector4), g_vertices);
	// 設定要變更GL_MODELVIEW矩陣
	glMatrixMode(GL_MODELVIEW);	

	// `旋轉角度`
	static float angle = 0.0f;
	angle += 0.01f;
	// `設定旋轉矩陣`
	Matrix4x4 world_view_matrix = g_view_matrix;
	world_view_matrix.RotateZ(angle);
	glLoadMatrixf( (float *) &world_view_matrix);
	// `畫出金字塔的8條邊線`
	glDrawElements(
		GL_LINES,	// `指定所要畫的基本圖形種類`
		16,			// `有幾個索引值`
		GL_UNSIGNED_SHORT,	// `索引值的型態`
		g_indices	// `索引值陣列`
		);

	// 把背景backbuffer的畫面呈現出來
	GutSwapBuffersOpenGL();
}
示例#2
0
// 使用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();
}
示例#3
0
// 使用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();
}
示例#4
0
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
	// 清除畫面
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glEnable(GL_DEPTH_TEST);

	// 設定好GPU要去哪讀取頂點座標資料
	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), &g_vertices[0].m_Position);
	// 設定好GPU要去哪讀取頂點顏色資料
	glEnableClientState(GL_COLOR_ARRAY);
	glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_VC), &g_vertices[0].m_RGBA);
	// 設定要變更GL_MODELVIEW矩陣
	glMatrixMode(GL_MODELVIEW);	

	// 設定轉換矩陣
	Matrix4x4 world_view_matrix = g_object_matrix * g_view_matrix;
	glLoadMatrixf( (float *) &world_view_matrix);
	// 畫出金字塔的8條邊線
	glDrawElements(
		GL_TRIANGLES, // 指定所要畫的基本圖形種類
		18, // 有幾個索引值
		GL_UNSIGNED_SHORT, // 索引值的型態
		g_indices // 索引值陣列
		);

	// 把背景backbuffer的畫面呈現出來
	GutSwapBuffersOpenGL();
}
示例#5
0
// 使用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();
}
示例#6
0
// `使用OpenGL來繪圖`
void RenderFrameOpenGL(void)
{
	// `清除畫面`
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glEnable(GL_DEPTH_TEST);

	// `設定好GPU要去哪讀取頂點座標資料`
	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), &g_vertices[0].m_Position);
	// `設定好GPU要去哪讀取頂點顏色資料`
	glEnableClientState(GL_COLOR_ARRAY);
	glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_VC), &g_vertices[0].m_RGBA);
	// `設定要變更GL_MODELVIEW矩陣`
	glMatrixMode(GL_MODELVIEW);	

	static float angle = 0.0f;
	angle += 0.01f;

	// `設定轉換矩陣`
	Matrix4x4 world_view_matrix = g_view_matrix;
	// `乘上旋轉矩陣`
	world_view_matrix.RotateZ(angle); 
	glLoadMatrixf( (float *) &world_view_matrix);
	// `畫出金字塔的8條邊線`
	glDrawElements(
		GL_TRIANGLES, // `指定所要畫的基本圖形種類`
		18, // `有幾個索引值`
		GL_UNSIGNED_SHORT, // `索引值的型態`
		g_indices // `索引值陣列`
		);

	// `把背景backbuffer的畫面呈現出來`
	GutSwapBuffersOpenGL();
}
示例#7
0
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
	Vector4 vPlane(0.0f, 0.0f, 1.0f, -g_mirror_z);

	// 清除畫面
	glClearColor(0.0f, 0.0f, 0.5f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
	// 畫出茶壼
	RenderModelOpenGL(false, NULL);
	// 設定轉換矩陣
	Matrix4x4 view_matrix = g_Control.GetViewMatrix();;
	Matrix4x4 world_view_matrix = view_matrix;

	glMatrixMode(GL_PROJECTION);
	glLoadMatrixf( (float *) &g_projection_matrix);

	glMatrixMode(GL_MODELVIEW);
	glLoadMatrixf( (float *) &world_view_matrix);

	sModelMaterial_OpenGL material;
	material.Submit(NULL);
	// 設定頂點資料格式
	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(3, GL_FLOAT, sizeof(Vertex_V), &g_Quad_v[0].m_Position);

	// 畫出鏡子, 同時把鏡子部分的stencil buffer設為1.
	{
		glEnable(GL_STENCIL_TEST);
		glStencilFunc(GL_ALWAYS, 1, 0xff);
		glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
		glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
		glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
	}
	// 把鏡子部分的zbuffer清為1.0
	{
		glStencilFunc(GL_EQUAL, 1, 0xff);
		glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
		// 把z值的輸出范圍設定為1~1, 也就是z永遠輸出1.
		glDepthRange(1.0f, 1.0f);
		glDepthFunc(GL_ALWAYS);
		// 只更新zbuffer,不需要更新顏色.
		glColorMask(false, false, false, false);
		glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
		// 恢復更新顏色的功能
		glColorMask(true, true, true, true);
		glDepthFunc(GL_LESS);
		// 把z值的范圍還原為0~1
		glDepthRange(0.0f, 1.0f);
	}
	// 畫出鏡子里的茶壼
	{
		glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
		RenderModelOpenGL(true, &vPlane);
		glDisable(GL_STENCIL_TEST);
	}
	// 把背景backbuffer的畫面呈現出來
	GutSwapBuffersOpenGL();
}
示例#8
0
// `使用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();
}
示例#9
0
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
	// 清除畫面
	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 *) &view_matrix);
	SetupLightingOpenGL();

	glLoadMatrixf( (float *) &world_view_matrix);
	g_Model_OpenGL.Render();

	// 把背景backbuffer的畫面呈現出來
	GutSwapBuffersOpenGL();
}
示例#10
0
// `使用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();
}
示例#11
0
// 使用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_COLOR_ARRAY);
	glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VCN), &g_Quad[0].m_Position);
	glColorPointer (4, GL_FLOAT, sizeof(Vertex_VCN), &g_Quad[0].m_Color);
	// 計算出一個可以轉換到鏡頭座標系的矩陣
	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);
	// 畫出格子
	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
	// 把背景backbuffer的畫面呈現出來
	GutSwapBuffersOpenGL();
}
示例#12
0
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
	// 清除畫面
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	// 計算出一個可以轉換到鏡頭座標系的矩陣
	Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
	// 計算出一個非平行投影的矩陣
	Matrix4x4 perspective_matrix = GutMatrixPerspectiveRH_OpenGL(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();
	}
	// 畫出金字塔的8條邊線
	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(4, GL_FLOAT, sizeof(Vector4), vertices);
	glDrawArrays(GL_LINES, 0, 16);
	// 把背景backbuffer的畫面呈現出來
	GutSwapBuffersOpenGL();
}
示例#13
0
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
	// 清除畫面
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// 計算出一個可以轉換到鏡頭座標系的矩陣
	Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
	// 設定鏡頭轉換矩陣
	glMatrixMode(GL_MODELVIEW);
	glLoadMatrixf((float *) &view_matrix);
	// 計算出一個非平行投影的透視矩陣
	Matrix4x4 perspective_matrix = GutMatrixPerspectiveRH_OpenGL(90.0f, 1.0f, 1.0f, 100.0f);
	// 設定視角轉換矩陣
	glMatrixMode(GL_PROJECTION);
	glLoadMatrixf((float *) &perspective_matrix);

	// 畫出金字塔的8條邊線
	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(4, GL_FLOAT, sizeof(Vector4), g_vertices);
	glDrawArrays(GL_LINES, 0, 16);

	// 把背景backbuffer的畫面呈現出來
	GutSwapBuffersOpenGL();
}
示例#14
0
// 使用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();
}
示例#15
0
// `使用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();
}
示例#16
0
// 使用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();
}
示例#17
0
// 使用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();
}
示例#18
0
// `使用OpenGL來繪圖`
void RenderFrameOpenGL(void)
{
	// `清除畫面`
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glEnable(GL_DEPTH_TEST);
	// `設定要用陣列的方式傳入頂點位置跟顏色`
	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_COLOR_ARRAY);
	// `計算出一個可以轉換到鏡頭座標系的矩陣`
	Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);
	Matrix4x4 world_view_matrix;

	glMatrixMode(GL_MODELVIEW);
	// `載入鏡頭轉換矩陣`
	glLoadMatrixf( (float *) &view_matrix );
	glPushMatrix(); // `把目前的矩陣存到stack里`
	// `太陽, 套入滑鼠的旋轉控制.`
	glRotatef(FastMath::RadianToDegree(g_fRotate_X), 1.0f, 0.0f, 0.0f);
	glRotatef(FastMath::RadianToDegree(g_fRotate_Y), 0.0f, 1.0f, 0.0f);
	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);
	// `水星`
	glPushMatrix(); // `把目前的矩陣存到stack里`
	float mercury_rotate_y = 360.0f * (g_simulation_days / days_a_year_mercury); 
	glRotatef(mercury_rotate_y, 0.0f, 1.0f, 0.0f);
	glTranslatef(mercury_to_sun_distance, 0.0f, 0.0f);
	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);
	// `從stack里pop出一個矩陣, 并套用到目前所指定要操作的矩陣`GL_MODELVIEW
	glPopMatrix(); 
	// `金星`
	glPushMatrix(); // `把目前的矩陣存到stack里`
	float venus_rotate_y = 360.0f * (g_simulation_days / days_a_year_venus); 
	glRotatef(venus_rotate_y, 0.0f, 1.0f, 0.0f);
	glTranslatef(venus_to_sun_distance, 0.0f, 0.0f);
	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);
	// `從stack里pop出一個矩陣, 并套用到目前所指定要操作的矩陣`GL_MODELVIEW
	glPopMatrix(); 
	// `地球`
	glPushMatrix();// `把目前的矩陣存到stack里`
	float earth_rotate_y = 360.0f * (g_simulation_days / days_a_year); 
	glRotatef(earth_rotate_y, 0.0f, 1.0f, 0.0f);
	glTranslatef(earth_to_sun_distance, 0.0f, 0.0f);
	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);
	// `月球`
	float moon_rotate_y = 360.0f * (g_simulation_days / days_a_month);
	glRotatef(moon_rotate_y, 0.0f, 1.0f, 0.0f);
	glTranslatef(moon_to_earth_distance, 0.0f, 0.0f);
	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);
	// `從stack里pop出一個矩陣, 并套用到目前所指定要操作的矩陣GL_MODELVIEW`
	glPopMatrix(); 
	glPopMatrix();

	// `把背景backbuffer的畫面呈現出來`
	GutSwapBuffersOpenGL();
}
示例#19
0
// 使用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();
}
示例#20
0
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
	// `清除畫面`
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glEnable(GL_DEPTH_TEST);
	// `設定要用陣列的方式傳入頂點位置跟顏色`
	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_COLOR_ARRAY);

	// `計算出一個可以轉換到鏡頭座標系的矩陣`
	Matrix4x4 view_matrix = GutMatrixLookAtRH(g_eye, g_lookat, g_up);

	Vector4 border(-15.0f, 0.0f, -15.0f);
	Vector4 grid_position = border;

	const int grids_x = 30;
	const int grids_z = 30;

	for ( int x=0; x<grids_x; x++ )
	{
		int grid_x = x & 0x07;
		grid_position[2] = border[2];

		for ( int z=0; z<grids_z; z++ )
		{
			int grid_z = z & 0x07;
			char c = g_map[grid_x][grid_z];

			// `設定轉換矩陣`
			Matrix4x4 object_matrix; object_matrix.Identity();

			if ( c==0 )
			{
				object_matrix = view_matrix;
				object_matrix.Translate(grid_position);
				glLoadMatrixf( (float *) &object_matrix);
				// `設定GPU要去哪讀取頂點座標資料`
				glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), &g_road_vertices[0].m_Position);
				// `設定GPU要去哪讀取頂點顏色資料`
				glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_VC), &g_road_vertices[0].m_RGBA);
				// `畫出地板`
				glDrawElements(
					GL_TRIANGLE_STRIP, // `指定所要畫的基本圖形種類`
					4, // `有幾個索引值`
					GL_UNSIGNED_SHORT, // `索引值的型態`
					g_road_trianglestrip_indices // `索引值陣列`
					);
			}
			else
			{
				// `設定金字塔的高度`
				object_matrix.Scale_Replace(1.0f, (float) c, 1.0f);
				object_matrix[3] = grid_position;
				Matrix4x4 world_view_matrix = object_matrix * view_matrix;
				glLoadMatrixf( (float *) &world_view_matrix);
				// `設定GPU要去哪讀取頂點座標資料`
				glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), &g_pyramid_vertices[0].m_Position);
				// `設定GPU要去哪讀取頂點顏色資料`
				glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex_VC), &g_pyramid_vertices[0].m_RGBA);
				// `畫出金字塔`
				glDrawElements(
					GL_TRIANGLE_FAN, // `指定所要畫的基本圖形種類`
					6, // `有幾個索引值`
					GL_UNSIGNED_SHORT, // `索引值的型態`
					g_pyramid_trianglefan_indices // `索引值陣列`
					);
			}

			grid_position[2] += 1.0f;
		}

		grid_position[0] += 1.0f;
	}

	// `把背景backbuffer的畫面呈現出來`
	GutSwapBuffersOpenGL();
}