`
tiankefeng0520
  • 浏览: 146869 次
  • 性别: Icon_minigender_1
  • 来自: 长春
社区版块
存档分类
最新评论

OpenGL学习十四：光照1

 
阅读更多
环境光：那些在环境中进行了充分的散射，无法辨别其方向的光，它似乎来自所有方向
散射光：来自某个方向。因此从它正面照射的表面，看起来更明亮以下。
镜面光：来自特定的方向，并且倾向于从表面的某个特定的方向放射

右图1:环境光 右图2：散射光 右图3：环境光与散射光的混合
 
       
创建光源
GLAPI void GLAPIENTRY glLightfv (GLenum light, GLenum pname, const GLfloat *params);

light:对应光源，一般支持0~7号光源
pname:光照信息参数
GL_AMBIENT                    环境光
GL_DIFFUSE                    散射光
GL_SPECULAR                   镜面光
GL_POSITION                   光源位置
GL_CONSTANT_ATTENUATION       常量衰减因子
GL_LINEAR_ATTENUATION         线性衰减因子
GL_QUADRATIC_ATTENUATION      二次衰减因子
params：参数

对于GL_LIGHT0与其他光源默认值不一致GL_LIGHT0的环境光和散射光的默认值是（1,1,1,1）
光源位置
GLfloat light_position[] = { x,y,z,w};
glLightfv(GL_LIGHT2, GL_POSITION, light_position);

w=0 为方向性光源
w!=0 为位置性光源
右图1：方向性光源（1,1,1，0）
右图2：位置性光源（1,1,1，1）
右图3：位置性光源（1,1,5，1）
       
光的衰减
衰减因子=1/k1+k2d+k3d*d
d=光源与顶点之间的距离
k1=GL_CONSTANT_ATTENUATION
k2=GL_LINEAR_ATTENUATION
k3=GL_QUADRATIC_ATTENUATION

说明光的衰减特效要求光源位位置性光源
右图1：光源位置z=5,k1=1
右图2：光源位置z=5,k1=3
   
材料属性
GLAPI void GLAPIENTRY glMaterialfv (GLenum face, GLenum pname, const GLfloat *params);

face:GL_FRONT,GL_BACK,GL_FRONT_AND_BACK
pname:GL_AMBIENT                    材料的环境颜色
      GL_DIFFUSE                    材料的散射颜色
      GL_SPECULAR                   材料的镜面颜色
      GL_SHININESS                  镜面指数
      GL_AMBIENT_AND_DIFFUSE        材料的环境和散射颜色
      GL_EMSSION                    材料的发射颜色
      GL_COLOR_INDEXS               颜色索引

球1：
  GLfloat mat_diffuse[] = { 0.1, 0.5, 0.8, 1.0 };
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);

球2：
   GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
   glMaterialfv(GL_FRONT, GL_SHININESS, 5);
球3：
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
   glMaterialfv(GL_FRONT, GL_SHININESS, 180)
球4：
   GLfloat mat_emission[] = {0.3, 0.2, 0.2, 0.0};
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
 
镜面反射
OPENGL允许我们在不存在反射光的情况下通过设置反射材料达到效果，并控制亮点的大小和亮点（GL_SHININESS）其实范围在【0~128】值越小亮度越大 亮点越小
发射颜色光
通过GL_EMISSION参数指定RGBA颜色值，可以使物体看上去好像发射这种颜色的光

材料颜色模式
glEnable(GL_COLOR_METERIAL)
glcolor3f(0.5,0.2,0.6);
glColorMeterial(GL_FRONT,GL_AMBIENT)

 

 

环境散射衰减光：

#include "header.h"	

 float roar=0.0f;
 GLfloat attentation[]={1.0};
 GLfloat light_position[] = { 1.0, 1.0,1, 0};

void init(void) 
{

   GLfloat ambient[] =  { 0.5, 0.5, 0.5, 0.0 };
   GLfloat diffuse[] = { 1.0, 0.0, 0.0, 0.0 };

   glClearColor (0.0, 0.0, 0.0, 0.0);


   glLightfv(GL_LIGHT1, GL_POSITION, light_position);
   glLightfv(GL_LIGHT1,GL_AMBIENT,ambient);
   glLightfv(GL_LIGHT2, GL_POSITION, light_position);
   glLightfv(GL_LIGHT2,GL_DIFFUSE,diffuse);
   glLightfv(GL_LIGHT3, GL_POSITION, light_position);
   glLightfv(GL_LIGHT3,GL_DIFFUSE,diffuse);
   glLightfv(GL_LIGHT3,GL_AMBIENT,ambient);

   glLightfv(GL_LIGHT1,GL_CONSTANT_ATTENUATION,attentation);
   glLightfv(GL_LIGHT2,GL_CONSTANT_ATTENUATION,attentation);
   glLightfv(GL_LIGHT3,GL_CONSTANT_ATTENUATION,attentation);


   glEnable(GL_LIGHTING);
   glEnable(GL_LIGHT0);

   glEnable(GL_DEPTH_TEST);
}

void display(void)
{
   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glLoadIdentity();
    glutSolidSphere(1.0, 16, 16);

   glFlush ();
}

void reshape (int w, int h)
{
   glViewport (0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity();
   if (w <= h)
      glOrtho (-2.5, 2.5, -2.5*(GLfloat)h/(GLfloat)w,
         2.5*(GLfloat)h/(GLfloat)w, -10.0, 10.0);
   else
      glOrtho (-2.5*(GLfloat)w/(GLfloat)h,
         2.5*(GLfloat)w/(GLfloat)h, -2.5, 2.5, -10.0, 10.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
}

void keyboard(unsigned char key, int x, int y)
{
   switch (key) 
   {
	 case '1':
		 glEnable(GL_LIGHTING);
		 glEnable(GL_LIGHT1);
		 glDisable(GL_LIGHT0);
		 glDisable(GL_LIGHT2);
		 glDisable(GL_LIGHT3);
     break;

	 case '2':
		 glEnable(GL_LIGHTING);
		 glEnable(GL_LIGHT2);
		 glDisable(GL_LIGHT0);
		 glDisable(GL_LIGHT1);
		 glDisable(GL_LIGHT3);
		 break;
	 case '3':
		 glEnable(GL_LIGHTING);
		 glEnable(GL_LIGHT3);
		 glDisable(GL_LIGHT0);
		 glDisable(GL_LIGHT2);
		 glDisable(GL_LIGHT1);
		 break;
	 case '0':
		 glEnable(GL_LIGHTING);
		 glEnable(GL_LIGHT0);
		 glDisable(GL_LIGHT1);
		 glDisable(GL_LIGHT2);
		 glDisable(GL_LIGHT3);
		 break;
	 case 'A':
		light_position[0]=1;
		light_position[1]=1;
		light_position[2]=1;
		light_position[3]=0;
		glLightfv(GL_LIGHT1, GL_POSITION, light_position);
		glLightfv(GL_LIGHT2, GL_POSITION, light_position);
		glLightfv(GL_LIGHT3, GL_POSITION, light_position);
		break;
	 case 'S':
		 light_position[0]=1;
		 light_position[1]=1;
		 light_position[2]=1;
		 light_position[3]=1;
		 glLightfv(GL_LIGHT1, GL_POSITION, light_position);
		 glLightfv(GL_LIGHT2, GL_POSITION, light_position);
		 glLightfv(GL_LIGHT3, GL_POSITION, light_position);
		 break;
	 case 'D':
		 light_position[0]=1;
		 light_position[1]=1;
		 light_position[2]=5;
		 light_position[3]=1;
		 glLightfv(GL_LIGHT1, GL_POSITION, light_position);
		 glLightfv(GL_LIGHT2, GL_POSITION, light_position);
		 glLightfv(GL_LIGHT3, GL_POSITION, light_position);
		 break;
	 case 'Z':
		 light_position[0]=1;
		 light_position[1]=1;
		 light_position[2]=5;
		 light_position[3]=1;
		 glLightfv(GL_LIGHT1, GL_POSITION, light_position);
		 glLightfv(GL_LIGHT2, GL_POSITION, light_position);
		 glLightfv(GL_LIGHT3, GL_POSITION, light_position);
		 attentation[0]=1;
		 glLightfv(GL_LIGHT1,GL_CONSTANT_ATTENUATION,attentation);
		 glLightfv(GL_LIGHT2,GL_CONSTANT_ATTENUATION,attentation);
		 glLightfv(GL_LIGHT3,GL_CONSTANT_ATTENUATION,attentation);

		 break;
	 case 'X':
		 light_position[0]=1;
		 light_position[1]=1;
		 light_position[2]=5;
		 light_position[3]=1;
		 attentation[0]=3;
		 glLightfv(GL_LIGHT1, GL_POSITION, light_position);
		 glLightfv(GL_LIGHT2, GL_POSITION, light_position);
		 glLightfv(GL_LIGHT3, GL_POSITION, light_position);
		 glLightfv(GL_LIGHT1,GL_CONSTANT_ATTENUATION,attentation);
		 glLightfv(GL_LIGHT2,GL_CONSTANT_ATTENUATION,attentation);
		 glLightfv(GL_LIGHT3,GL_CONSTANT_ATTENUATION,attentation);
		 break;
   }
   glutPostRedisplay();
} 

void rotate()
{
	roar+=0.0001f;
	glutPostRedisplay();
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize (500, 500); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape);
   glutKeyboardFunc(keyboard);
   glutMainLoop();
   return 0;
}

 移动光源

#include "header.h"

static int spin = 0;

void init(void) 
{
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel (GL_SMOOTH);
   glEnable(GL_LIGHTING);
   glEnable(GL_LIGHT0);
   glEnable(GL_DEPTH_TEST);
}

void display(void)
{
   GLfloat position[] = { 0.0, 0.0, 1.5, 1.0 };

   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glPushMatrix ();
   gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

   glPushMatrix ();
   glRotated ((GLdouble) spin, 1.0, 0.0, 0.0);
   glLightfv (GL_LIGHT0, GL_POSITION, position);

   glTranslated (0.0, 0.0, 1.5);
   glDisable (GL_LIGHTING);
   glColor3f (0.0, 1.0, 1.0);
   glutWireCube (0.1);
   glEnable (GL_LIGHTING);
   glPopMatrix ();

   glutSolidTorus (0.275, 0.85, 8, 15);
   glPopMatrix ();
   glFlush ();
}

void reshape (int w, int h)
{
   glViewport (0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity();
   gluPerspective(40.0, (GLfloat) w/(GLfloat) h, 1.0, 20.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
}

void mouse(int button, int state, int x, int y)
{
   switch (button) {
      case GLUT_LEFT_BUTTON:
         if (state == GLUT_DOWN) {
            spin = (spin + 30) % 360;
            glutPostRedisplay();
         }
         break;
      default:
         break;
   }
}

void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
   }
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize (500, 500); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape);
   glutMouseFunc(mouse);
   glutKeyboardFunc(keyboard);
   glutMainLoop();
   return 0;
}


 

 光源材料

#include "header.h"


void init(void)
{
   GLfloat ambient[] = { 0.0, 0.0, 0.0, 1.0 };
   GLfloat diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
   GLfloat position[] = { 0.0, 3.0, 2.0, 0.0 };
   GLfloat lmodel_ambient[] = { 0.4, 0.4, 0.4, 1.0 };
   GLfloat local_view[] = { 0.0 };

   glClearColor(0.0, 0.1, 0.1, 0.0);
   glEnable(GL_DEPTH_TEST);
   glShadeModel(GL_SMOOTH);

   glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
   glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
   glLightfv(GL_LIGHT0, GL_POSITION, position);
   glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
   glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, local_view);

   glEnable(GL_LIGHTING);
   glEnable(GL_LIGHT0);
}


void display(void)
{
   GLfloat no_mat[] = { 0.0, 0.0, 0.0, 1.0 };
   GLfloat mat_ambient[] = { 0.7, 0.7, 0.7, 1.0 };
   GLfloat mat_ambient_color[] = { 0.8, 0.8, 0.2, 1.0 };
   GLfloat mat_diffuse[] = { 0.1, 0.5, 0.8, 1.0 };
   GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
   GLfloat no_shininess[] = { 0.0 };
   GLfloat low_shininess[] = { 5.0 };
   GLfloat high_shininess[] = { 100.0 };
   GLfloat mat_emission[] = {0.3, 0.2, 0.2, 0.0};

   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);


   glPushMatrix();
   glTranslatef (-3.75, 3.0, 0.0);
   glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat);
   glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess);
   glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
   glutSolidSphere(1.0, 16, 16);
   glPopMatrix();


   glPushMatrix();
   glTranslatef (-1.25, 3.0, 0.0);
   glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
   glMaterialfv(GL_FRONT, GL_SHININESS, low_shininess);
   glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
   glutSolidSphere(1.0, 16, 16);
   glPopMatrix();

   glPushMatrix();
   glTranslatef (1.25, 3.0, 0.0);
   glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
   glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
   glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
   glutSolidSphere(1.0, 16, 16);
   glPopMatrix();


   glPushMatrix();
   glTranslatef (3.75, 3.0, 0.0);
   glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat);
   glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess);
   glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
   glutSolidSphere(1.0, 16, 16);
   glPopMatrix();


   glPushMatrix();
   glTranslatef (-3.75, 0.0, 0.0);
   glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat);
   glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess);
   glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
   glutSolidSphere(1.0, 16, 16);
   glPopMatrix();

   glPushMatrix();
   glTranslatef (-1.25, 0.0, 0.0);
   glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
   glMaterialfv(GL_FRONT, GL_SHININESS, low_shininess);
   glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
   glutSolidSphere(1.0, 16, 16);
   glPopMatrix();

   glPushMatrix();
   glTranslatef (1.25, 0.0, 0.0);
   glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
   glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
   glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
   glutSolidSphere(1.0, 16, 16);
   glPopMatrix();


   glPushMatrix();
   glTranslatef (3.75, 0.0, 0.0);
   glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat);
   glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess);
   glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
   glutSolidSphere(1.0, 16, 16);
   glPopMatrix();

   glPushMatrix();
   glTranslatef (-3.75, -3.0, 0.0);
   glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat);
   glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess);
   glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
   glutSolidSphere(1.0, 16, 16);
   glPopMatrix();


   glPushMatrix();
   glTranslatef (-1.25, -3.0, 0.0);
   glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
   glMaterialfv(GL_FRONT, GL_SHININESS, low_shininess);
   glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
   glutSolidSphere(1.0, 16, 16);
   glPopMatrix();


   glPushMatrix();
   glTranslatef (1.25, -3.0, 0.0);
   glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
   glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
   glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
   glutSolidSphere(1.0, 16, 16);
   glPopMatrix();


   glPushMatrix();
   glTranslatef (3.75, -3.0, 0.0);
   glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat);
   glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess);
   glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
   glutSolidSphere(1.0, 16, 16);
   glPopMatrix();

   glFlush();
}

void reshape(int w, int h)
{
   glViewport(0, 0, w, h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   if (w <= (h * 2))
      glOrtho (-6.0, 6.0, -3.0*((GLfloat)h*2)/(GLfloat)w, 
         3.0*((GLfloat)h*2)/(GLfloat)w, -10.0, 10.0);
   else
      glOrtho (-6.0*(GLfloat)w/((GLfloat)h*2), 
         6.0*(GLfloat)w/((GLfloat)h*2), -3.0, 3.0, -10.0, 10.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
}

void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
   }
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize (600, 450);
   glutCreateWindow(argv[0]);
   init();
   glutReshapeFunc(reshape);
   glutDisplayFunc(display);
   glutKeyboardFunc (keyboard);
   glutMainLoop();
   return 0; 
}

 材料颜色模式

#include "header.h"

GLfloat diffuseMaterial[4] = { 0.5, 0.5, 0.5, 1.0 };


void init(void) 
{
   GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
   GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };

   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel (GL_SMOOTH);
   glEnable(GL_DEPTH_TEST);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuseMaterial);
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
   glMaterialf(GL_FRONT, GL_SHININESS, 25.0);
   glLightfv(GL_LIGHT0, GL_POSITION, light_position);
   glEnable(GL_LIGHTING);
   glEnable(GL_LIGHT0);

   glColorMaterial(GL_FRONT, GL_DIFFUSE);
   glEnable(GL_COLOR_MATERIAL);
}

void display(void)
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glutSolidSphere(1.0, 20, 16);
   glFlush ();
}

void reshape (int w, int h)
{
   glViewport (0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity();
   if (w <= h)
      glOrtho (-1.5, 1.5, -1.5*(GLfloat)h/(GLfloat)w,
         1.5*(GLfloat)h/(GLfloat)w, -10.0, 10.0);
   else
      glOrtho (-1.5*(GLfloat)w/(GLfloat)h,
         1.5*(GLfloat)w/(GLfloat)h, -1.5, 1.5, -10.0, 10.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
}

void mouse(int button, int state, int x, int y)
{
   switch (button) {
      case GLUT_LEFT_BUTTON:
         if (state == GLUT_DOWN) {
            diffuseMaterial[0] += 0.1;
            if (diffuseMaterial[0] > 1.0)
               diffuseMaterial[0] = 0.0;
            glColor4fv(diffuseMaterial);
            glutPostRedisplay();
         }
         break;
      case GLUT_MIDDLE_BUTTON:
         if (state == GLUT_DOWN) {
            diffuseMaterial[1] += 0.1;
            if (diffuseMaterial[1] > 1.0)
               diffuseMaterial[1] = 0.0;
            glColor4fv(diffuseMaterial);
            glutPostRedisplay();
         }
         break;
      case GLUT_RIGHT_BUTTON:
         if (state == GLUT_DOWN) {
            diffuseMaterial[2] += 0.1;
            if (diffuseMaterial[2] > 1.0)
               diffuseMaterial[2] = 0.0;
            glColor4fv(diffuseMaterial);
            glutPostRedisplay();
         }
         break;
      default:
         break;
   }
}

void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
   }
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize (500, 500); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape);
   glutMouseFunc(mouse);
   glutKeyboardFunc(keyboard);
   glutMainLoop();
   return 0;
}

 
  • 大小: 4.3 KB
  • 大小: 5.4 KB
  • 大小: 5.8 KB
  • 大小: 7.5 KB
  • 大小: 6.8 KB
  • 大小: 7.8 KB
  • 大小: 8.2 KB
  • 大小: 6.8 KB
  • 大小: 21.5 KB
分享到：
| OpenGL学习十二：显示列表
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    OpenGL.rar_OPENGL 纹理_OPENGL光照_OpenGL光照纹理_opengl 光照

    OpenGL是一种广泛应用于游戏开发、图形渲染和科学可视化等领域...要深入学习和理解这些概念，你可以查看压缩包内的源代码、教程或示例，这将有助于你亲自动手实践OpenGL的纹理和光照技术，进一步提升你的图形编程能力。

    OpenGL光照基础Demo

    通过学习和实践OpenGL光照基础Demo，开发者可以掌握如何在实际项目中应用光照模型，创建更加逼真的3D场景。了解这些基础知识对于进一步学习高级光照技术，如法线贴图、光泽贴图和环境光遮蔽等，都是至关重要的。因此...

    OPENGL光照和纹理技术实例.rar

    学习这个实例，开发者不仅可以掌握基本的OpenGL光照和纹理应用，还能理解如何将这些技术结合，以创建更为逼真的3D场景。在实际项目中，这些技能对于游戏开发、可视化应用、科学模拟等领域都至关重要。

    OpenGL.rar_opengl_opengl 光照_光照

    这个“OpenGL.rar”压缩包包含了与OpenGL光照处理相关的代码示例，可以帮助开发者学习如何在OpenGL环境中实现复杂的光照效果。 在OpenGL中，光照是通过模拟现实世界中的光传播来增强场景的真实感。它涉及到光源、...

    opengl光照小例子

    OpenGL是一种强大的图形库，用于在各种操作系统和平台上创建2D和3D图形。光照是OpenGL渲染中的关键元素，它极大地影响了...通过这个例子，你可以学习如何在OpenGL环境中创建逼真的光照效果，从而提升你的图形编程技能。

    OpenGL实验八犹他茶壶光照、阴影、纹理

    在这个实验中，我们将深入探讨OpenGL中的光照、阴影和纹理这三大关键概念。 光照是创建真实感3D图像的重要部分。OpenGL提供了一系列模型来模拟不同光源对物体的影响，包括点光源、平行光和聚光灯。这些光源可以设置...

    OpenGL光源、材质和光照模型源代码

    OpenGL是计算机图形学中广泛使用的应用编程接口（API），它...总结，这个资源为初学者提供了一个学习OpenGL光照系统的基础平台，通过源代码的学习和实践，可以提升对3D图形编程的理解，进而创建出更为逼真的3D场景。

    OpenGL光照效果.rar_dll_opengl_opengl dll_opengl 光照_光照

    如果要深入学习，你应该查看这些资源，理解代码逻辑，运行并调整参数，观察不同设置对光照效果的影响。 为了实现高质量的聚光效果，你还需要理解视锥体的概念，因为它会影响聚光灯在场景中的表现。视锥体是摄像机...

    openGL三种光照模型 1.Gouraud 着色 2.phong 3.Blinn-Phong反射模型

    OpenGL是计算机图形学中用于创建和操作2D和3D图形的强大库。在OpenGL中，光照模型对于模拟现实世界中的物体...在"lightBlinnPhong"这个压缩包中，可能包含了实现这三种光照模型的示例代码或教程，供学习者参考和实践。

    Opengl-光照球体

    在这个"Opengl-光照球体"项目中，我们将深入探讨如何在OpenGL环境中创建一个带有光照效果的球体，并添加纹理背景，实现一个可直接运行的程序。 首先，我们需要理解OpenGL中的光照模型。在3D图形渲染中，光照是影响...

    ogl_lighting.rar_ogl_lighting_opengl_opengl 光照_光照_模拟

    总的来说，这个OpenGL程序是一个很好的学习光照效果的实例，通过模拟光照的变化，帮助开发者理解光源、材质和光照模型在图形渲染中的作用。对于希望深入学习OpenGL光照系统的人来说，这是一个值得研究的示例。

    opengl图形学实验七 不同的光照渲染

    OpenGL是一种强大的跨语言、跨平台的图形...总的来说，这个实验是学习和实践OpenGL光照渲染的重要步骤，它帮助开发者掌握创建逼真3D场景的技能，对于游戏开发、可视化应用和图形设计等领域都具有重要的理论和实践价值。

    OpenGL光照球体

    在实际应用中，"lightsphere"示例可以帮助学习者理解如何在OpenGL环境中模拟复杂的光照效果，例如环境光、漫射光、镜面光等，以及如何通过光照模型的调整来改变场景的视觉效果。此外，它还可以作为进一步研究高级...

    opengl.zip_OPENGL光照_opengl 球

    在这个"opengl.zip"压缩包中，重点探讨的是OpenGL的光照处理和如何创建球体模型，这些都是3D图形渲染的基础部分。 首先，我们要理解OpenGL中的光照模型。在3D图形世界里，物体的外观很大程度上取决于光线与物体表面...

    openGL 光照范例

    在这个模型中，我们可以学习到OpenGL如何处理光照效果，这对于3D图形渲染至关重要。光照在3D环境中起到决定性作用，它可以增强场景的真实感，使物体看起来更加立体和生动。 首先，我们来了解OpenGL中的光照模型。...

    OpenGL 实验七 光照与材质练习

    实验七“光照与材质练习”是学习OpenGL编程的一个重要环节，它涵盖了如何在3D场景中模拟真实世界的光照和物体表面材质，从而提高图像的真实感。 在OpenGL中，光照和材质是两个关键概念。光照主要涉及光源、物体和...

    opengl有纹理有贴图有光照有影子的青花瓷茶壶

    在这个“opengl有纹理有贴图有光照有影子的青花瓷茶壶”项目中，开发者使用了OpenGL来实现一个复杂的视觉效果，其中包括了纹理映射、贴图、光照计算以及阴影生成。以下是对这些技术的详细解释： 1. **纹理映射...

    opengl.rar_OpenGL画圆_opengl_opengl 光照

    总的来说，这个示例项目提供了一个学习和理解OpenGL如何处理2D几何形状和光照效果的好机会。通过深入研究"drawball.cpp"的代码，你可以学习到如何在实际项目中实现这些功能，这对任何想要从事图形编程的人来说都是...

    Opengl漫游+碰撞检测+光照

    OpenGL是一种强大的图形编程接口，广泛应用于游戏开发、科学可视化、工程设计等领域。在这个"OpenGL漫游+碰撞检测+光照"的项目中，我们将探讨几个关键...这个OpenGL项目为学习和掌握这些核心概念提供了一个实用的平台。

    OpenGL 例程.rar_OPENGL 纹理_openGl例程_opengl c++_opengl 光照

    8. **www.pudn.com.txt**：这可能是一个链接或说明文档，指向更多关于OpenGL学习资源的网站pudn.com。 通过学习和运行这些示例，初学者可以深入理解OpenGL的工作原理，逐步掌握3D图形编程的关键技术。同时，对光照...

Magicbox
Global site tag (gtag.js) - Google Analytics