采用 GLM 从代码层面理解 OpenGL 坐标系统

const GLfloat vertices_leftup[] = ｛ // left up red
	-1.0f, -0.5f, -1.0f,
	 0.0f, -0.5f, -1.0f,
	-0.5f,  1.0f, -1.0f,
｝;
const GLfloat vertices_leftdown[] = ｛ // left down blue
	-1.0f, -1.0f, 0.5f,
	 0.0f, -1.0f, 0.5f,
	-0.5f,  0.5f, 0.5f,
｝;
const GLfloat vertices_rightup[] = ｛ // right up red
	0.0f, -0.5f, 0.5f,
	1.0f, -0.5f, 0.5f,
	0.5f,  1.0f, 0.5f,
｝;
const GLfloat vertices_rightdown[] = ｛ // right down blue
	0.0f, -1.0f, -1.0f,
	1.0f, -1.0f, -1.0f,
	0.5f,  0.5f, -1.0f,
｝;
const GLfloat vertices_rect[] = ｛ // center green
	-1.0f, -0.5f, 0.0f,
	 1.0f, -0.5f, 0.0f,
	 1.0f,  0.5f, 0.0f,
	-1.0f,  0.5f, 0.0f,
｝; 

/// Build a look at view matrix based on the default handedness.
/// @param eye Position of the camera
/// @param center Position where the camera is looking at
/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
template <typename T, precision P>
GLM_FUNC_DECL tmat4x4<T, P> lookAt(
	tvec3<T, P> const & eye,
	tvec3<T, P> const & center,
	tvec3<T, P> const & up);

void
calc_distance_from_camera() ｛
	glm::vec4 somepoint(5.0f, 5.0f, 5.0f, 1.0f);
	glm::vec3 camerapos(2.0f, 2.0f, 2.0f);
	glm::mat4 viewmat = glm::lookAt(camerapos, glm::vec3(0, 0, 0), glm::vec3(0, 1.0f, 0));
	glm::vec4 somepoint_view = viewmat * somepoint; // transform somepoint to view space
	// 当只有 view matrix 时，也可以计算出摄像机的位置，下面代码就展示了这种计算方式，
	// 至于原理可以先忽略，涉及到数学的部分总是让人害怕。
	glm::mat4 viewmat_inverse = glm::inverse(viewmat);
	glm::vec3 camerapos_calc(viewmat_inverse[3]);
	printf("here camera pos: %.2f %.2f, %.2f\n", camerapos.x, camerapos.y, camerapos.z);
	printf("calc camera pos: %.2f %.2f, %.2f\n", camerapos_calc.x, camerapos_calc.y, camerapos_calc.z);
	// 计算点 somepoint 距离摄像机的距离
	// 方式 1 ，在 world space 中计算距离
	float distance_world = glm::distance2(glm::vec3(somepoint), camerapos_calc);
	printf("distance calc in world space:%.2f\n", distance_world);
	// 方式 2 ，在 view space 中计算距离，
	// view space 就是在摄像机位置中观看对象，此时摄像机就相当于原点
	glm::vec3 camerapos_view(0, 0, 0);
	float distance_view = glm::distance2(glm::vec3(somepoint_view), camerapos_view);
	printf("distance calc in view space:%.2f\n", distance_view);
｝
输出结果如下：
here camera pos: 2.00 2.00, 2.00
calc camera pos: 2.00 2.00, 2.00
distance calc in world space:27.00
distance calc in view space:27.00

/// Creates a matrix for a symetric perspective-view frustum based on the default handedness.
/// @param fovy Specifies the field of view angle in the y direction. Expressed in radians.
/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
template <typename T>
GLM_FUNC_DECL tmat4x4<T, defaultp> perspective(T fovy, T aspect, T near, T far);

void 
calc_near_far() ｛
	// 采用右手坐标系验证
	float neardistance = 1.0f;
	float fardistance = 100.0f;
	glm::mat4 persmat = glm::perspectiveRH(glm::radians(45.0f), 800.0f/600.0f, neardistance, fardistance);
	// NDC 是基于左手坐标系的，近平面对应的 NDC 坐标的 z 轴的值是 -1.0f ，
	// 而远平面对应的 NDC 坐标的 z 轴的值是 1.0f 。
	glm::vec4 near_ndc(0, 0, -1.0f, 1.0f);
	glm::vec4 far_ndc(0, 0, 1.0f, 1.0f);
	// 由于我们逆运算这个 ndc 坐标之前所在的世界坐标位置，所以我们要先求逆矩阵。
	glm::mat4 inverse_permat = glm::inverse(persmat);
	glm::vec4 near_world = inverse_permat * near_ndc;
	glm::vec4 far_world = inverse_permat * far_ndc;
	printf("before /w: \tnear_world:<%9.3f,%9.3f,%9.3f,%9.3f>\n\t\tfar_world: <%9.3f,%9.3f,%9.3f,%9.3f>\n", 
		near_world.x, near_world.y, near_world.z, near_world.w, 
		far_world.x, far_world.y, far_world.z, far_world.w);
	// 我们知道 OpenGL 会自动进行透视除法（/w）来将透视矩阵转换后的坐标最终转换成 NDC 。
	// 而刚刚乘以逆矩阵只消除了透视投影，未消除透视除法，
	// 这时还应该再除以 w 分量，让 w 分量为 1 来消除透视除法的影响。
	near_world /= near_world.w;
	far_world /= far_world.w;
	printf("after /w: \tnear_world:<%9.3f,%9.3f,%9.3f,%9.3f>\n\t\tfar_world: <%9.3f,%9.3f,%9.3f,%9.3f>\n",
		near_world.x, near_world.y, near_world.z, near_world.w, 
		far_world.x, far_world.y, far_world.z, far_world.w);
	printf("see, in right-hand the z axis of result match -neardistance and -fardistance\n");
｝
输出结果如下：
before /w:      near_world:<    0.000,    0.000,   -1.000,    1.000>
                far_world: <    0.000,    0.000,   -1.000,    0.010>
after /w:       near_world:<    0.000,    0.000,   -1.000,    1.000>
                far_world: <    0.000,    0.000, -100.000,    1.000>
see, in right-hand the z axis of result match -neardistance and -fardistance 

const GLchar *vertexcode = 
"#version 330 core \n"
"layout(location = 0) in vec4 pos_modelspace; \n"
"out vec4 o_color; \n"
"void main() ｛ \n"
"	gl_Position = pos_modelspace; \n"
"｝";
const GLchar *fragmentcode = 
"#version 330 core \n"
"uniform vec3 bg; \n"
"out vec3 color; \n"
"in vec4 o_color; \n"
"void main() ｛ \n"
"	color = bg; \n"
"｝";

// 位置属性包含 4 个元素 (x, y, z, w) ，直接在这里进行矩阵计算。
void
initdraw(int len, GLfloat **multi_vertices, GLuint *boarr, int trianglebytes, const glm::mat4 &view, const glm::mat4 &perspective) ｛
	GLfloat *ptr, *startptr;
	int attrnum = trianglebytes / (sizeof(GLfloat) * VERTEX_POSATTR_NUM);
	printf("init draw now, [triangle num:%d] [vertex num per triangle:%d]\n", len, attrnum);
	for (int i = 0; i < len; i++) ｛
		printf("init draw with triangle:%d\n", i);
		GLfloat *triangle = multi_vertices[i];
		glBindBuffer(GL_ARRAY_BUFFER, boarr[i]);
		glBufferData(GL_ARRAY_BUFFER, trianglebytes, NULL, GL_STATIC_DRAW);
		startptr = ptr = (GLfloat*)glMapBufferRange(GL_ARRAY_BUFFER, 0, trianglebytes, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
		for (int j = 0; j < attrnum; j++) ｛
			GLfloat *vertex = triangle + j * VERTEX_POSATTR_NUM;
			ptr = startptr + j * VERTEX_POSATTR_NUM;
			glm::vec4 point(vertex[0], vertex[1], vertex[2], vertex[3]); // 位置属性包含的元素
			printf("before point:%d %10.3f,%10.3f,%10.3f,%10.3f\n", j, vertex[0], vertex[1], vertex[2], vertex[3]);
			point = perspective * view * point; // 坐标转换
			printf("after point :%d %10.3f,%10.3f,%10.3f,%10.3f\n", j, point.x, point.y, point.z, point.w);
			printf("after /w    :%d %10.3f,%10.3f,%10.3f\n", j, point.x/point.w, point.y/point.w, point.z/point.w);
			memcpy(ptr, glm::value_ptr(point), sizeof(point));
		｝
		if (glUnmapBuffer(GL_ARRAY_BUFFER) == GL_FALSE)
			printf("fail to unmap buffer\n");
		glBindBuffer(GL_ARRAY_BUFFER, 0);
	｝
	fflush(stdout);
｝
void 
startdraw(int len, GLuint *boarr, GLuint bglocation, GLfloat **bgarr) ｛
	for (int i = 0; i < len; i++) ｛
		glUniform3fv(bglocation, 1, bgarr[i]);
		glBindBuffer(GL_ARRAY_BUFFER, boarr[i]);
		glVertexAttribPointer(0, VERTEX_POSATTR_NUM, GL_FLOAT, GL_FALSE, 0, 0);
		glDrawArrays(GL_TRIANGLES, 0, 3);	
	｝
｝

viewleft=glm::translate(viewleft,glm::vec3(0.0f,0.0f,-10.0f));  
viewright=glm::translate(viewright,glm::vec3(0.0f,0.0f,4.0f));