OpenGL 离散化后的到扭曲的三角形

参考用书：OpenGL编程基础-第三版

在OpenGL 三角形离散化之后只显示外边界中我们将三角形分割为几个小三角形。这时大家可能都会有疑问，这样做有什么意义？绘制出来的效果不还是三角形吗？本次我们将实现一个三角形扭曲后得到的的类似飓风形状的图案。

原理介绍

我们考虑二维扭曲：

如果我们令旋转的角度由该点到原点的距离决定，那么就是对对象进行了扭曲而非简单的旋转。

代码：

下面给出程序:

#include<GL/glut.h>
#include<math.h>

float twist = 0.5;	//旋转的弧度 = twist * 待顶点到原点的距离

void triangle(GLfloat *, GLfloat *, GLfloat *,int );//绘制一个三角形
void divide_triangle(GLfloat *, GLfloat *, GLfloat *, int , int);//从一个三角形开始递归地细分n次
void display()
{
	GLfloat v[3][2] = { -0.5, -0.5, 0.5, -0.5, 0, 0.5};
	glClear(GL_COLOR_BUFFER_BIT);  //清除颜色缓存
	divide_triangle(v[0], v[1],v[2],4,0);
	glFlush();
}

void init()
{
	glClearColor(0.0, 0.0, 0.0, 0.0);//设置清屏颜色为黑色
	//由函数glClearColor设置的颜色必须指定为RGBA颜色，A指的是透明度，而且每个分量的类型必须是GLclampf
	glColor3f(1.0, 1.0, 1.0);//设置绘制颜色为白色
	
	glMatrixMode(GL_PROJECTION);  //指定投影矩阵会收到后续变换函数的影响
	glLoadIdentity();//将当前矩阵初始化为单位矩阵
	gluOrtho2D(-1.0, 1.0, -1.0,  1.0);
	//背面和正面都应该设置为非填充图元，画线的时候顺时针为背面
	glPolygonMode(GL_FRONT, GL_LINE);
}

int main(int argc, char ** argv)
{
	glutInit(&argc,argv);   //初始化GLUT，应在其他GLUT和OpenGL函数之前进行调用
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);//指定窗口类型，RGB颜色和单缓存
	glutInitWindowSize(500,500);//指定窗口大小
	glutInitWindowPosition(0,0);//指定窗口左上角相对于屏幕左上角的位置
	glutCreateWindow("simple");  //创建窗口并命名为"simple"
	glutDisplayFunc(display); //指定回调函数
	init();
	glutMainLoop();   //使程序进入无限事件处理循环，该函数的调用应作为main函数最后一条语句出现
}

//绘制一个三角形
void triangle(GLfloat *a, GLfloat *b, GLfloat *c,int type)
{
	GLfloat v[2];	//存储旋转后得到的顶点坐标
	double d;
	glBegin(GL_POLYGON);
		switch(type)
		{
		case(2):
		case(4):
		case(6):
		case(7):
			glEdgeFlag(GL_FALSE);
			break;
		default:
			glEdgeFlag(GL_TRUE);
			break;
		}
		d= sqrt(a[0] * a[0] + a[1] * a[1]) ;
		v[0] = cos(twist * d) * a[0] - sin(twist *d) * a[1];
		v[1] = sin(twist * d) * a[0] + cos (twist * d) * a[1];
		glVertex2fv(v);
		switch(type)
		{
		case(3):
		case(4):
		case(5):
		case(7):
			glEdgeFlag(GL_FALSE);
			break;
		default:
			glEdgeFlag(GL_TRUE);
			break;
		}
		d= sqrt(b[0] * b[0] + b[1] * b[1]) ;
		v[0] = cos(twist * d) * b[0] -  sin (twist *d) * b[1];
		v[1] = sin (twist * d) * b[0] + cos(twist * d) *b[1];
		glVertex2fv(v);
				switch(type)
		{
		case(1):
		case(5):
		case(6):
		case(7):
			glEdgeFlag(GL_FALSE);
			break;
		default:
			glEdgeFlag(GL_TRUE);
			break;
		}
		d= sqrt(c[0] * c[0] +c[1] * c[1]) ;
		v[0] = cos(twist * d) * c[0] -  sin (twist *d) *c[1];
		v[1] = sin (twist * d) * c[0] + cos(twist * d) *c[1];
		glVertex2fv(v);
	glEnd();
}

//从一个三角形开始递归地细分n次
void divide_triangle(GLfloat * a, GLfloat * b, GLfloat * c, int m,int k)
{
	GLfloat v[3][2];	
	int j;
	int flag[4];

	if(m>0)
	{
		for(j = 0;j < 2 ;j++) 
			v[0][j] = (a[j] + b[j]) /2;
		for(j = 0;j < 2 ;j++) 
			v[1][j] = (a[j] + c[j]) /2;
		for(j = 0;j < 2 ;j++) 
			v[2][j] = (c[j] + b[j]) /2;

		switch(k)
		{
		case(0):
			flag[0] = 3;
			flag[1] = 1;
			flag[2] = 2;
			break;
		case(1):
			flag[0] = 5;
			flag[1] = 1;
			flag[2] = 6;
			break;
		case(2):
			flag[0] = 4;
			flag[1] = 6;
			flag[2] = 2;
			break;
		case(3):
			flag[0] = 3;
			flag[1] = 5;
			flag[2] = 4;
			break;
		case(4):
			flag[0] = 4;
			flag[1] = 7;
			flag[2] = 4;
			break;
		case(5):
			flag[0] = 5;
			flag[1] = 5;
			flag[2] = 7;
			break;
		case(6):
			flag[0] = 7;
			flag[1] = 6;
			flag[2] = 6;
			break;
		case(7):
			flag[0] = 7;
			flag[1] = 7;
			flag[2] = 7;
			break;
		}
		flag[3] = 7;
		divide_triangle(a, v[0], v[1], m-1, flag[0]);
		divide_triangle(v[0], b, v[2], m-1, flag[1]);
		divide_triangle(v[1], v[2], c, m-1, flag[2]);
		divide_triangle(v[0], v[2], v[1], m-1, flag[3]);
	}
	else
		triangle(a, b, c, k);
}

运行截图：

修改divide_triangle(GLfloat *, GLfloat *, GLfloat *, int , int)的第四个参数
离散化一次的结果：

离散化两次的结果：

离散化三次的结果：

可以看到在第三次便实现了平滑的曲面效果