之前自学OPENGL的时候根据书上的东西，模仿着写了一些小东西

这是一个简单的彩色扇形拼接，我用了FLAT取消了颜色的渐变，当时感觉挺好玩的。



#include <glut.h>
#include<math.h>;

const int n =30 ;
const GLfloat R = 0.5f;
const GLfloat Pi = 3.14159265354f;
const GLfloat factor = 0.1f;
void myDisplay(void)

{
 int i;
  glShadeModel(GL_FLAT);//取消渐变
 glClear(GL_COLOR_BUFFER_BIT);
 glBegin(GL_TRIANGLE_FAN);
 glColor3f(1.0f, 1.0f, 1.0f);
 glVertex2f(0.0f, 0.0f);
 
 for (i = 0; i <= 8; ++i)//多个扇形拼接
 {
  glColor3f(i & 0x04, i & 0x02, i & 0x01);//每个定点取不同颜色
  glVertex2f(cos(i*Pi / 4), sin(i*Pi / 4));
 }
 glEnd();
 glFlush();

}

int main(int argc, char *argv[])

{

 glutInit(&argc, argv);
  
 glutInitDisplayMode(GLUT_RGBA | GLUT_SINGLE);

 glutInitWindowPosition(100, 100);

 glutInitWindowSize(400, 400);

 glutCreateWindow("第一个OpenGL程序");

 glutDisplayFunc(&myDisplay);

 glutMainLoop();

 return 0;

}

然后做了简单的3D的太阳系动画，但是很头疼的是按照书上的写出来不显示，头疼了2天，翻了好几本书，终于找到了问题，真的是要命。弄刀最后还是视角没调好。

之后我做了一个简单的光照，没想到光照颜色覆盖了物体本身的颜色，一脸懵逼。

#include<glut.h>
#include <time.h>
#include<iostream>
using namespace std;
static int day = 200;

double CalFrequency()//计算FPS
{
 static int count;
 static double save;
 static clock_t last, current;
 double timegap;

 ++count;//计算帧数
 if (count <= 50)//取50帧
  return 0;
 count = 0;
 last = current;
 current = clock();
 timegap = (current - last) / (double)CLK_TCK;//50帧的时间
 save = 50.0 / timegap;
 return save;

}
void myDisplay(void)
{
 double FPS = CalFrequency();
 if(FPS!=0)
   cout << FPS << endl; 
 
 
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 gluPerspective(75, 1,10000, 400000000);//显示黑屏的问题所在
 
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 gluLookAt(0, -200000000, 200000000, 0, 0, 0, 0, 0, 1);
 
 //定义太阳光源（白色）
 GLfloat sun_light_pos[] = { 0.0f,0.0f,0.0f,1.0f };
 GLfloat sun_light_amb[] = { 0.0f,0.0f,0.0f,1.0f };
 GLfloat sun_light_diff[] = { 1.0f,1.0f,1.0f,1.0f };
 GLfloat sun_light_spec[] = { 1.0f,1.0f,1.0f,1.0f };

 glLightfv(GL_LIGHT0, GL_POSITION, sun_light_pos);
 glLightfv(GL_LIGHT0, GL_AMBIENT, sun_light_amb);
 glLightfv(GL_LIGHT0, GL_DIFFUSE, sun_light_diff);
 glLightfv(GL_LIGHT0, GL_SPECULAR, sun_light_spec);
 //开启光照效果
 glEnable(GL_LIGHT0);
 glEnable(GL_LIGHTING);
 glEnable(GL_DEPTH_TEST);
 glEnable(GL_COLOR_MATERIAL);
 //红太阳
 //材质
 GLfloat sun_mat_amb[] = { 0.0f,0.0f,0.0f,0.2f };
 GLfloat sun_mat_diff[] = { 0.0f,0.0f,0.0f,0.2f };
 GLfloat sun_mat_spec[] = { 0.0f,0.0f,0.0f,0.2f };
 GLfloat sun_mat_emiss[] = { 0.5f,0.0f,0.0f,1.0f };
 GLfloat sun_mat_shini = 0.0f;

 glMaterialfv(GL_FRONT, GL_AMBIENT, sun_mat_amb);
 glMaterialfv(GL_FRONT, GL_DIFFUSE, sun_mat_diff);
 glMaterialfv(GL_FRONT, GL_SPECULAR, sun_mat_spec);
 glMaterialfv(GL_FRONT, GL_EMISSION, sun_mat_emiss);
 glMaterialf(GL_FRONT, GL_SHININESS, sun_mat_shini);
 
 //绘制
 glColor3f(1.0f, 0.0f, 0.0f);
 glutSolidSphere(69600000, 200, 200);
 
 //蓝地球
 //材质
 /*GLfloat earth_mat_amb[] = { 0.0f,0.0f,0.5f,1.0f };
 GLfloat earth_mat_diff[] = { 0.0f,0.0f,0.5f,1.0f };
 GLfloat earth_mat_spec[] = { 0.0f,0.0f,1.0f,1.0f };
 GLfloat earth_mat_emiss[] = { 0.5f,0.0f,0.0f,1.0f };
 GLfloat earth_mat_shini = 30.0f;

 glMaterialfv(GL_FRONT, GL_AMBIENT, earth_mat_amb);
 glMaterialfv(GL_FRONT, GL_DIFFUSE, earth_mat_diff);
 glMaterialfv(GL_FRONT, GL_SPECULAR, earth_mat_spec);
 glMaterialfv(GL_FRONT, GL_EMISSION, earth_mat_emiss);
 glMaterialf(GL_FRONT, GL_SHININESS, earth_mat_shini);*/
 //绘制
 glColor3f(0.0f, 1.0f, 0.0f);
 glRotatef(day , 0.0f,0.0f, -1.0f);
 glTranslatef(150000000, 0.0f, 0.0f);
 glutSolidSphere(15945000, 200,   200);

 //黄月亮
 glColor3f(1.0f, 1.0f, 0.0f);
 glRotatef(day / 30.0*360.0 - day / 360.0*360.0, 0.0f, 0.0f, -1.0f);
 glTranslatef(38000000, 0.0f, 0.0f);
 glutSolidSphere(4345000, 200, 200);
 
 
 glFlush();
 glutSwapBuffers();
}

void myIdle(void)//刷新
{
 ++day;
 if (day >= 360)
  day = 0;
 myDisplay();
}

int main(int argc,char *argv[])
{
 glutInit(&argc, argv);
 glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE|GLUT_DEPTH);
 glutInitWindowPosition(100,100);
 glutInitWindowSize(400, 400);
 glutCreateWindow("旋转体系");
 
 glutDisplayFunc(&myDisplay);
 glutIdleFunc(&myIdle);
 
 glutMainLoop();
 return 0;
}

有一次教U3D的老师让我们做一个6*6的方块阵列= =！然后我突然就手痒，用POENGL来做，于是我炸了。

OPENGL的矩阵移动会不断叠加，导致不能用和U3D相同的逻辑来写，一开始写的炒鸡复杂（见注释掉的部分）。晚上的时候想了想，原来可以在生成一个方块的时候把矩阵还原掉（/摊手），扎心了，瞬间觉得自己好蠢。 这两天看到了压栈（扶额），我的天，我弄的好麻烦，一个压栈完美解决啊。。。

#include<glut.h>
float a =1;
float b = 1;
int n1 = 6;

void myDisplay(void)
{
 //glEnable(GLUT_DEPTH);
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 gluPerspective(75, 1, 5,500);

 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 gluLookAt(20, 20, 20, 3, 3, 3, 0, 0, 1);

 ////生成方块
 //for (int z = 0; z < 6; z++)
 //{
 // for (int y = 0; y < 6; y++)
 // {
 //  for (int x = 0; x < n1; x++)
 //  {
 //   glTranslatef(a, 0, 0);
 //   glutSolidCube(1);

 //  }
 //  a = -a;
 //  if (y != 5)
 //  {
 //   glTranslatef(0, b, 0);
 //   glutSolidCube(1);
 //  }
 //  if (n1 == 6)
 //   n1--;
 // }
 // b = -b;
 // if (z != 5)
 // {
 //  glTranslatef(0, 0,1);
 //  glutSolidCube(1);
 // }
 // 
 //}
 for (int z = 0; z < 6; z++)
 {
  glTranslatef(0, 0, z+0.3);
  for (int y = 0; y < 6; y++)
  {
   glTranslatef(0, y+0.3, 0);
   for (int x = 0; x < 6; x++)
   {
    glTranslatef(x+0.3, 0, 0);
    glutSolidCube(1);
    glTranslatef(-x-0.3, 0, 0);
   }
   glTranslatef(0, -y-0.3, 0);
  }
  glTranslatef(0, 0, -z-0.3);
 }
 glFlush();
}

int main(int argc,char*argv[])
{
 glutInit(&argc, argv);
 glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH);
 glutInitWindowPosition(100, 100);
 glutInitWindowSize(400, 400);
 glutCreateWindow("作业");

 glutDisplayFunc(&myDisplay);
 glutMainLoop();
 return 0;

}
 

最后是一个旋转的三角锥，本来是五彩的，然后我加了光照（变得惨不忍睹）。

#include<GLTools.h>
#include<GLShaderManager.h>
#include<GLBatch.h>
#include<GL/glut.h>

#include<math.h>
#define  IWIDTH  400
#define  IHEIGHT 400
#define ColoredVertex(c,v)do{glColor3fv(c);glVertex3fv(v);}while(0)

GLfloat angle = 0.0f;

void setNormal(GLfloat* Point1, GLfloat* Point2, GLfloat* Point3)
{
 GLfloat normal[3];
 int i;
 for (i = 0; i<3; ++i)
  normal[i] = (Point1[i] + Point2[i] + Point3[i]) / 3;
 glNormal3fv(normal);
}

void myDisplay(void)
{   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 //光源
 GLfloat light_pos[] = { 0,0,10,1 };
 GLfloat light_amb[] = { 0,0,0,1 };
 GLfloat light_diff[] = { 1,1,1,1 };
 GLfloat light_spec[] = { 1,1,1,1 };

 glLightfv(GL_LIGHT0, GL_POSITION, light_pos);
 glLightfv(GL_LIGHT0, GL_AMBIENT, light_amb);
 glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diff);
 glLightfv(GL_LIGHT0, GL_SPECULAR, light_spec);

 glEnable(GL_LIGHT0);
 glEnable(GL_LIGHTING);
 glEnable(GL_DEPTH_TEST);
 
 static int list = 0;
 if (list == 0)
 {//显示列表不存在的时候创建一个原型
  GLfloat
   PointA[] = { 0.5f, -sqrt(6.0f) / 12, -sqrt(3.0f) / 6 },
   PointB[] = { -0.5f, -sqrt(6.0f) / 12, -sqrt(3.0f) / 6 },
   PointC[] = { 0.0f, -sqrt(6.0f) / 12, sqrt(3.0f) / 3 },
   PointD[] = { 0.0f, sqrt(6.0f) / 4, 0 };
  GLfloat
   ColorR[] = { 1, 0, 0 },
   ColorG[] = { 0, 1, 0 },
   ColorB[] = { 0, 0, 1 },
   ColorY[] = { 1, 1, 0 };
  /*GLfloat
   mat_amb[] = { 0,0,0,1 },
   mat_diff[] = { 0,0,0,1 },
   mat_spec[] = { 0,0,0,1 },
   mat_emis[] = {0,0,1,1},
   mat_shin = 0.2f;*/

  list = glGenLists(1);
  glNewList(list, GL_COMPILE);
  glBegin(GL_TRIANGLES);
  /*glMaterialfv(GL_FRONT, GL_AMBIENT, mat_amb);
  glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diff);
  glMaterialfv(GL_FRONT, GL_SPECULAR, mat_spec);
  glMaterialfv(GL_FRONT, GL_EMISSION, mat_emis);
  glMaterialf(GL_FRONT, GL_SHININESS, mat_shin);*/
  
  //ABC
  ColoredVertex(ColorR, PointA);
  ColoredVertex(ColorG, PointB);
  ColoredVertex(ColorB, PointC);
  setNormal(PointA, PointB, PointC);
  //ACD
  ColoredVertex(ColorR, PointA);
  ColoredVertex(ColorB, PointC);
  ColoredVertex(ColorY, PointD);
  setNormal(PointA, PointC, PointD);
  // 平面 CBD
  ColoredVertex(ColorB, PointC);
  ColoredVertex(ColorG, PointB);
  ColoredVertex(ColorY, PointD);
  setNormal(PointC, PointB, PointD);
  // 平面 BAD
  ColoredVertex(ColorG, PointB);
  ColoredVertex(ColorR, PointA);
  ColoredVertex(ColorY, PointD);
  setNormal(PointB, PointA, PointD);
  glEnd();
  glEndList();

  
 }
 
 

 glPushMatrix();
 glRotatef(angle, 1, 0.5, 0);
 glCallList(list);
 glPopMatrix();
 glutSwapBuffers();//实现双缓存
}

void myIdle(void)
{
 ++angle;
 if (angle >= 360.0f)
  angle = 0.0f;
 myDisplay();
}

int main(int argc, char*argv[])
{
 glutInit(&argc, argv);
 glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
 glutInitWindowPosition(200, 200);
 glutInitWindowSize(IWIDTH, IHEIGHT);
 glutCreateWindow("旋转锥");
 glutDisplayFunc(&myDisplay);
 glutIdleFunc(&myIdle);
 glutMainLoop();
 return 0;
}