VS2012下基于Glut 矩阵变换示例程序2：

在VS2012下基于Glut 矩阵变换示例程序：中我们在绘制甜圈或者圆柱时使用矩阵对相应的坐标进行变换后自己绘制甜圈或者圆柱。我们也可以使用glLoadMatrixf、glLoadMatrixd载入变换矩阵后直接使用Glut提供的函数绘制甜圈。这里我在载入变换矩阵后再去绘制坐标轴，所以在程序运行时坐标轴会随着定时器绕Y轴旋转。点击鼠标右键在弹出的菜单里面可以选择是否显示坐标轴、正视图还是透视视图、是否打印变换矩阵。

源代码在VS2012下基于Glut 矩阵变换示例程序：只修改了：

GlutTransformDemo.cpp

// GlutTransformDemo.cpp : 定义控制台应用程序的入口点。
//


#include "stdafx.h"
#include <gl/glut.h>
#include <math.h>
#include "math3d.h"
//圆周率宏
#define GL_PI 3.1415f
//获取屏幕的宽度
GLint SCREEN_WIDTH=0;
GLint SCREEN_HEIGHT=0;
//设置程序的窗口大小
GLint windowWidth=400;
GLint windowHeight=300;
//绕x轴旋转角度
GLfloat xRotAngle=0.0f;
//绕y轴旋转角度
GLfloat yRotAngle=0.0f;
//受支持的点大小范围
GLfloat sizes[2];
//受支持的点大小增量
GLfloat step;
//最大的投影矩阵堆栈深度
GLint iMaxProjectionStackDepth;
//最大的模型视图矩阵堆栈深度
GLint iMaxModeviewStackDepth;
//最大的纹理矩阵堆栈深度
GLint iMaxTextureStackDepth;

GLint iCoordinateaxis=2;//是否显示坐标轴
GLint iProjectionMode=1;//投影模式
GLint iPrintMatrix=1;//是否打印变换矩阵
void changSize(GLint w,GLint h);

void DrawTorus(M3DMatrix44f mTransform){  
    // 大圆只存在于 xy 平面，  
    // 小圆存在于 xyz 空间中，  
    // 其圆心是大圆圆周上的点。  
    // 小圆环大圆半径方向为起始旋转一周形成的。  
    // 由于 z 轴垂直于 xy 平面，  
    // 又因为大圆的半径位于 xy 平面，  
    // 因此，z 轴垂直于大圆的半径（垂直于面，垂直于线），  
    // 因此，z 轴与大圆的半径方向是正交的。  
    // 小圆位于 z 轴与大圆半径方向形成的平面，  
    // 后面计算具体点的位置是基于上面的描述。  
      
    // 大圆半径  
    GLfloat majorRadius = 55.0f;  
    // 小圆半径  
    GLfloat minorRadius = 15.0f;  
    // 大圆圆周被切分的点数  
    GLint   numMajor = 50;  
    // 小圆圆周被切分的点数  
    GLint   numMinor = 20;  
    M3DVector3f objectVertex;         // Vertex in object/eye space  
    M3DVector3f transformedVertex;    // New Transformed vertex  
    // 每个点对应的弧度数  
    double majorStep = 2.0f*M3D_PI / numMajor;  
    double minorStep = 2.0f*M3D_PI / numMinor;  
    int i, j;  
      
    // 对于大圆上的点进行迭代  
    for (i=0; i<numMajor; ++i)   
        {  
        // 第一个点对应的弧度  
        double a0 = i * majorStep;  
        // 第二个点对应的弧度  
        double a1 = a0 + majorStep;  
        // 第一个点在 x 与 y 轴上的单位长度  
        GLfloat x0 = (GLfloat) cos(a0);  
        GLfloat y0 = (GLfloat) sin(a0);  
        // 第二个点在 x 与 y 轴上的单位长度  
        GLfloat x1 = (GLfloat) cos(a1);  
        GLfloat y1 = (GLfloat) sin(a1);  
  
        glBegin(GL_TRIANGLE_STRIP);  
        // 对小圆上的点进行迭代  
        for (j=0; j<=numMinor; ++j)   
            {  
            // 小圆上点对应的弧度  
            double b = j * minorStep;  
            // 小圆上点在半径方向的单位长度  
            GLfloat c = (GLfloat) cos(b);  
            // 小圆上点，在xy 平面的分量长度  
            GLfloat r = minorRadius * c + majorRadius;  
            // 小圆上点在 z 轴上的长度  
            GLfloat z = minorRadius * (GLfloat) sin(b);  
              
            // 小圆上点坐标确认的过程：将该点分为在 z 轴 与 大圆半径方向，由于大圆半径只存在于 xy 平面，就相对容易求到 x ， y 坐标。  
              
            // First point  
            objectVertex[0] = x0*r;// 小圆上点对应的 x 坐标  
            objectVertex[1] = y0*r;// 小圆上点对应的 y 坐标  
            objectVertex[2] = z; // 小圆上点对应的 z 坐标  
            m3dTransformVector3(transformedVertex, objectVertex, mTransform);  
            glVertex3fv(transformedVertex);  
  
            // Second point  
            objectVertex[0] = x1*r;  
            objectVertex[1] = y1*r;  
            objectVertex[2] = z;  
            m3dTransformVector3(transformedVertex, objectVertex, mTransform);  
            glVertex3fv(transformedVertex);  
            }  
        glEnd();  
        }  
}  

void DrawCylinder(M3DMatrix44f mTransform){  
    // 大圆半径  
    GLfloat majorRadius = 55.0f;  
    // 大圆圆周被切分的点数  
    GLint   numMajor = 100;  

    M3DVector3f objectVertex;         // Vertex in object/eye space  
    M3DVector3f transformedVertex;    // New Transformed vertex  
    // 每个点对应的弧度数  
    double majorStep = 2.0f*M3D_PI / numMajor;  
  
    glBegin(GL_TRIANGLE_STRIP);  
    // 对于大圆上的点进行迭代  
    for (int i=0; i<=numMajor; ++i)   
        {  

        // 第一个点对应的弧度  
        double a0 = i * majorStep;  
        // 第二个点对应的弧度  
        double a1 = a0 - majorStep;  
        // 第一个点在 x 与 y 轴上的单位长度  
        GLfloat x0 = (GLfloat) cos(a0);  
        GLfloat y0 = (GLfloat) sin(a0);  
        // 第二个点在 x 与 y 轴上的单位长度  
        GLfloat x1 = (GLfloat) cos(a1);  
        GLfloat y1 = (GLfloat) sin(a1);  
  
		// First point  
		objectVertex[0] = x0*majorRadius;// 小圆上点对应的 x 坐标  
		objectVertex[1] = y0*majorRadius;// 小圆上点对应的 y 坐标  
		objectVertex[2] = 50.0f; // 小圆上点对应的 z 坐标  
		m3dTransformVector3(transformedVertex, objectVertex, mTransform);  
		glVertex3fv(transformedVertex);  

		// Second point  
		objectVertex[0] = x1*majorRadius;  
		objectVertex[1] = y1*majorRadius;  
		objectVertex[2] = -50.0f;  
		m3dTransformVector3(transformedVertex, objectVertex, mTransform);  
		glVertex3fv(transformedVertex); 
		}
        glEnd();  
}  

//菜单回调函数
void processMenu(int value){
	switch(value){
		case 1:
			iCoordinateaxis=1;
			break;
		case 2:
			iCoordinateaxis=2;
			break;
		case 3:
			iProjectionMode=1;
			//强制调用窗口大小变化回调函数，更改投影模式为正交投影
			changSize(glutGet(GLUT_WINDOW_WIDTH),glutGet(GLUT_WINDOW_HEIGHT));
			break;
		case 4:
			iProjectionMode=2;
			//强制调用窗口大小变化回调函数，更改投影模式为透视投影
			changSize(glutGet(GLUT_WINDOW_WIDTH),glutGet(GLUT_WINDOW_HEIGHT));
			break;
		case 5:
			iPrintMatrix=1;
			break;
		case 6:
			iPrintMatrix=2;
			break;
		default:
			break;
	}
	//重新绘制
	glutPostRedisplay();
}

//显示回调函数
void renderScreen(void){
    M3DMatrix44f   transformationMatrix;   // Storeage for rotation matrix
    static GLfloat yRot = 0.0f;         // Rotation angle for animation
    yRot += 0.5f;
	//将窗口颜色清理为黑色
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    //把整个窗口清理为当前清理颜色：黑色；清除深度缓冲区。
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

    //将当前Matrix状态入栈
    glPushMatrix();
    //坐标系绕x轴旋转xRotAngle
    glRotatef(xRotAngle,1.0f,0.0f,0.0f);
    //坐标系绕y轴旋转yRotAngle
    glRotatef(yRotAngle,0.0f,1.0f,0.0f);
	//进行平滑处理　
	glEnable(GL_POINT_SMOOTH);
	glHint(GL_POINT_SMOOTH,GL_NICEST);
	glEnable(GL_LINE_SMOOTH);
	glHint(GL_LINE_SMOOTH,GL_NICEST);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);

	memset(transformationMatrix,0,sizeof(transformationMatrix));
	//打印变换矩阵
	if(2==iPrintMatrix){
		printf("--------------------------------------\n");
		for(int i=0;i<4;i++){
			for(int j=0;j<4;j++){
				printf("%9.6f ",transformationMatrix[4*j+i]);
			}
			printf("\n");
		}
	}
    m3dRotationMatrix44(transformationMatrix, m3dDegToRad(yRot), 0.0f, 1.0f, 0.0f);
	//transformationMatrix[12]、transformationMatrix[13] = 0.0f、transformationMatrix[14] = 0.0f是平移参数,分别代表x、y、 z轴的偏移参数。
	//transformationMatrix[15]代表缩放为原来的1/transformationMatrix[15]
	if(2==iProjectionMode){
		transformationMatrix[12] = 0.0f;
		transformationMatrix[13] = 0.0f;
		transformationMatrix[14] = -250.0f;//透视投影为便于观察整个坐标系往内移动250个单位
		transformationMatrix[15] = 1.0f; 
	}
	//打印变换矩阵
	if(2==iPrintMatrix){
		printf("--------------------------------------\n");
		for(int i=0;i<4;i++){
			for(int j=0;j<4;j++){
				printf("%9.6f ",transformationMatrix[4*j+i]);
			}
			printf("\n");
		}
	}
	//载入变换矩阵
	glLoadMatrixf(transformationMatrix);
	//绘制坐标系
    if(1==iCoordinateaxis){
		glColor3f(1.0f,1.0f,1.0f);
		glBegin(GL_LINES);
			glVertex3f(-90.0f,00.0f,0.0f);
			glVertex3f(90.0f,0.0f,0.0f);
			glVertex3f(0.0f,-90.0f,0.0f);
			glVertex3f(0.0f,90.0f,0.0f);
			glVertex3f(0.0f,0.0f,-90.0f);
			glVertex3f(0.0f,0.0f,90.0f);
		glEnd();

		glPushMatrix();
		glTranslatef(90.0f,0.0f,0.0f);
		glRotatef(90.0f,0.0f,1.0f,0.0f);
		glutSolidCone(3,6,10,10);
		glPopMatrix();

		glPushMatrix();
		glTranslatef(0.0f,90.0f,0.0f);
		glRotatef(-90.0f,1.0f,0.0f,0.0f);
		glutSolidCone(3,6,10,10);
		glPopMatrix();

		glPushMatrix();
		glTranslatef(0.0f,0.0f,90.0f);
		glRotatef(70.0f,0.0f,0.0f,1.0f);
		glutSolidCone(3,6,10,10);
		glPopMatrix();
	}
	glColor3f(0.5f,0.5f,1.0f);
	glutWireTorus(15.0f,50.0f,40,30); 
    //恢复压入栈的Matrix
    glPopMatrix();
    //交换两个缓冲区的指针
    glutSwapBuffers();
}

//设置Redering State 
void setupRederingState(void){
    glEnable(GL_DEPTH_TEST);	//使能深度测试
    glFrontFace(GL_CCW);		//多边形逆时针方向为正面
    //glEnable(GL_CULL_FACE);		//不显示背面
	glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);//背面正面均使用线填充

    //设置清理颜色为黑色
    glClearColor(0.0f,0.0,0.0,1.0f);
    //设置绘画颜色为绿色
    glColor3f(1.0f,1.0f,0.0f);
	//使能深度测试
	glEnable(GL_DEPTH_TEST);
	//获取受支持的点大小范围
	glGetFloatv(GL_POINT_SIZE_RANGE,sizes);
	//获取受支持的点大小增量
	glGetFloatv(GL_POINT_SIZE_GRANULARITY,&step);
	//获取最大的投影矩阵堆栈深度
	glGetIntegerv( GL_MAX_PROJECTION_STACK_DEPTH,&iMaxProjectionStackDepth);
	//获取最大的模型视图矩阵堆栈深度
	glGetIntegerv( GL_MAX_MODELVIEW_STACK_DEPTH,&iMaxModeviewStackDepth);
	//获取最大的纹理矩阵堆栈深度
	glGetIntegerv( GL_MAX_TEXTURE_STACK_DEPTH,&iMaxTextureStackDepth);
	printf("point size range:%f-%f\n",sizes[0],sizes[1]);
	printf("point step:%f\n",step);
	printf("iMaxProjectionStackDepth=%d\n",iMaxProjectionStackDepth);
	printf("iMaxModeviewStackDepth=%d\n",iMaxModeviewStackDepth);
	printf("iMaxTextureStackDepth=%d\n",iMaxTextureStackDepth);
}

//窗口大小变化回调函数
void changSize(GLint w,GLint h){
    //横宽比率
    GLfloat ratio;
    //设置坐标系为x(-100.0f,100.0f)、y(-100.0f,100.0f)、z(-100.0f,100.0f)
    GLfloat coordinatesize=100.0f;
    //窗口宽高为零直接返回
    if((w==0)||(h==0))
        return;
    //设置视口和窗口大小一致
    glViewport(0,0,w,h);
    //对投影矩阵应用随后的矩阵操作
    glMatrixMode(GL_PROJECTION);
    //重置当前指定的矩阵为单位矩阵　
    glLoadIdentity();
    ratio=(GLfloat)w/(GLfloat)h;
    //正交投影
	if(1==iProjectionMode){
		printf("glOrtho\n");
		if(w<h)
			glOrtho(-coordinatesize,coordinatesize,-coordinatesize/ratio,coordinatesize/ratio,-coordinatesize,coordinatesize);
		else
			glOrtho(-coordinatesize*ratio,coordinatesize*ratio,-coordinatesize,coordinatesize,-coordinatesize,coordinatesize);
		//当前矩阵设置为模型视图矩阵
		glMatrixMode(GL_MODELVIEW);
		//重置当前指定的矩阵为单位矩阵　
		glLoadIdentity();
	}
	else{
		printf("gluPerspective\n");
		gluPerspective(45,ratio,10.0f,500.0f);
		//当前矩阵设置为模型视图矩阵
		glMatrixMode(GL_MODELVIEW);
		//重置当前指定的矩阵为单位矩阵　
		glLoadIdentity();
	}

}

//按键输入处理回调函数
void specialKey(int key,int x,int y){

    if(key==GLUT_KEY_UP){
        xRotAngle-=5.0f;
    }
    else if(key==GLUT_KEY_DOWN){
        xRotAngle+=5.0f;
    }
    else if(key==GLUT_KEY_LEFT){
        yRotAngle-=5.0f;
    }
    else if(key==GLUT_KEY_RIGHT){
        yRotAngle+=5.0f;
    }
    //重新绘制
    glutPostRedisplay();
}

void timerFunc(int value)
{
	glutPostRedisplay();
	glutTimerFunc(10, timerFunc, 1);
}

int main(int argc, char* argv[])
{
	//菜单
	GLint iMainMenu;
	GLint iCoordinateaxisMenu;
	GLint iOrthoOrPerspectMenu;
	GLint iPrintmatrix;
	//初始化glut 
    glutInit(&argc,argv);
    //使用双缓冲区、深度缓冲区。
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH);
    //获取系统的宽像素
    SCREEN_WIDTH=glutGet(GLUT_SCREEN_WIDTH);
    //获取系统的高像素
    SCREEN_HEIGHT=glutGet(GLUT_SCREEN_HEIGHT);
	//创建窗口，窗口名字为OpenGL Transform Demo
    glutCreateWindow("OpenGL Transform Demo");
    //设置窗口大小
    glutReshapeWindow(windowWidth,windowHeight);
    //窗口居中显示
    glutPositionWindow((SCREEN_WIDTH-windowWidth)/2,(SCREEN_HEIGHT-windowHeight)/2);
    //窗口大小变化时的处理函数
    glutReshapeFunc(changSize);
    //设置显示回调函数 
    glutDisplayFunc(renderScreen);
    //设置按键输入处理回调函数
    glutSpecialFunc(specialKey);
	//菜单回调函数
	iCoordinateaxisMenu=glutCreateMenu(processMenu);
	//添加菜单
	glutAddMenuEntry("Display coordinate axis",1);
	glutAddMenuEntry("Don't dispaly coordinate axis",2);
	iOrthoOrPerspectMenu=glutCreateMenu(processMenu);
	glutAddMenuEntry("Ortho",3);
	glutAddMenuEntry("Perspect",4);
	iPrintmatrix=glutCreateMenu(processMenu);
	glutAddMenuEntry("Don't print Matrix",5);
	glutAddMenuEntry("Print Matrix",6);
	iMainMenu=glutCreateMenu(processMenu);
	glutAddSubMenu("Whether Display coordinate axis",iCoordinateaxisMenu);
	glutAddSubMenu("Ortho Or Perspect",iOrthoOrPerspectMenu);
	glutAddSubMenu("Whether Print Matrix",iPrintmatrix);
	//将菜单榜定到鼠标右键上
	glutAttachMenu(GLUT_RIGHT_BUTTON);
	glutTimerFunc(10,timerFunc, 1);
    //设置全局渲染参数
    setupRederingState();
    glutMainLoop();
	
    return 0;
}