OpenGL学习十四：光照1

最新推荐文章于 2022-08-22 16:06:48 发布
最新推荐文章于 2022-08-22 16:06:48 发布
阅读量143 收藏
点赞数
分类专栏： OpenGL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tiankefeng0520/article/details/84521992
版权
环境光：那些在环境中进行了充分的散射，无法辨别其方向的光，它似乎来自所有方向
散射光：来自某个方向。因此从它正面照射的表面，看起来更明亮以下。
镜面光：来自特定的方向，并且倾向于从表面的某个特定的方向放射

右图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;
}

 

tiankefeng0520
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenGL的函数
行秋的博客
12-22 676
glMaterialfv() void glMaterialfv(GLenum face, GLenum pname, TYPE (*)param); 指定用于光照计算的当前材质属性。参数face的取值可以是GL_FRONT、GL_BACK或GL_FRONT_AND_BACK，指出材质属性将应用于物体的哪面。pname指出要设置的哪种材质属性。param为要设置的属性值，是一个指向数组的指针（向量版本）或一个数值（非向量版本）。只有设置GL_SHININESS时，才能使用非向量版本。下表列举出了参数pn
OpenGL笔记7 光线空间
爱不释手lc
08-30 395
转载自:http://www.cnblogs.com/mattins/p/4081933.html OpenGL笔记7 光线空间 　　今天要讲的是OpenGL光照的基本知识。虽然内容显得有点多，但条理还算比较清晰，理解起来应该没有困难。即使对于一些内容没有记住，问题也不大——光照部分是一个比较独立的内容，它的学习与其它方面的学习可以分开，不像视图变换那样，影响到
OpenGL光照设置
cfz751740465的博客
11-09 5900
光照模型 OpenGL光照模型分为三种光：Ambient Light 环境光, Diffuse Light漫反射光, Specular Light镜面反射光. 一、创建光源 void glLightfv (GLenum light, GLenum pname, const GLfloat *params) light: OpenGL提供8个光源 GL_LIGHT0 ~ GL_LIGHT7 pname: 光源属性 GL_AMBIENT 环境光 默认 (0.0, 0...
3.2 光照篇（2）
weixin_30367945的博客
04-02 373
http://book.51cto.com/art/201104/255655.htm 3.2 光照篇（2） 2．光源 事实上光源才是所有光照效果的基础，没有光源一切都无从谈起。OpenGL中我们可以设置８个光源，其编号分别为GL_LIGHT0、GL_LIGHT1、……、GL_LIGHT7。就相当于现实生活中有８个太阳，但每个太阳的位置、方向及它发出的光线可以完全不同。因此，OpenGL...
用glLightfv函数实现简单的光照效果
weixin_63545354的博客
05-04 2423
制作真实的动画需要添加光照效果， 首先介绍OpenGL的简单光照模型，它的反射光可以分为三个分量：环境反射光，漫反射光，镜面反射光。就是你要实现一个光照效果，需要设置这三个分量，三者之和达到你想要的光照效果。 1.环境光，简单来说就是环境中的光，似乎来自于各个方向 2.漫反射，来自一个方向，光它照射到物体上，则在各个方向上均匀地发散出去，不管视点在哪，物体都是一样亮。 3.镜面光，来自特定方向，并沿着另一方向反射出去。 ...
OpenGL.rar_opengl_opengl 光照_光照
09-21
这个“OpenGL.rar”压缩包包含了与OpenGL光照处理相关的代码示例，可以帮助开发者学习如何在OpenGL环境中实现复杂的光照效果。 在OpenGL中，光照是通过模拟现实世界中的光传播来增强场景的真实感。它涉及到光源、...
opengl.zip_OPENGL光照_opengl 球
最新发布
09-24
在这个"opengl.zip"压缩包中，重点探讨的是OpenGL的光照处理和如何创建球体模型，这些都是3D图形渲染的基础部分。 首先，我们要理解OpenGL中的光照模型。在3D图形世界里，物体的外观很大程度上取决于光线与物体表面...
openGL ADS光照
02-17
通过阅读和理解这些代码，你可以学习到如何在OpenGL中设置光照和应用Phong着色模型，从而创建出逼真的3D场景。 总之，“OpenGL ADS光照”是一个涉及光照模型、Phong着色理论和OpenGL着色器编程的实践课题。通过学习...
OpenGL.rar_OpenGL 光_opengl 光照
09-23
本文将深入探讨OpenGL中的光照模型及其在实际绘图中的应用，包括视图模型转换、背景颜色设置、明暗模型等关键概念。 首先，让我们了解OpenGL光照模型的基础。光照模型是OpenGL中模拟真实世界光线如何与物体表面相互...
OpenGL.rar_OPENGL 纹理_OPENGL光照_OpenGL光照纹理_opengl 光照
09-22
OpenGL是一种广泛应用于游戏开发、图形渲染和科学可视化等领域...要深入学习和理解这些概念，你可以查看压缩包内的源代码、教程或示例，这将有助于你亲自动手实践OpenGL的纹理和光照技术，进一步提升你的图形编程能力。
OpenGL编程指南-光照
yanglusheng的专栏
10-29 662
OpenGL通过光源、材料和光照模型，渲染光照物体，模拟现实世界1.光源1.创建光源 OpenGL至少支持8个光源，即GL_LIGHT0到GL_LIGHT7，可以使用glEnable开启光源 2.设置光源属性 设置光源方向：glLightfv(GL_LIGHT0, GL_POSITION,position) 设置环境光：glLightfv(GL_LIGHT0,GL_AMBIENT,light_a
《计算机图形学》实验 5
qq_45823118的博客
12-25 1945
一、实验目的： 1） 理解光照模型； 2） 生成带光照模型的图形 二、实验内容 共有三道题目。请根据给定的实验结果样例，结合参考程序设计程序，实现样例的显示效果，把程序代码和实验截图拷贝到实验报告中。 题目 1： 设计程序实现点光源移动时，球体的观察效果. 效果： 代码： #include <gl/glut.h> void init(void) { //光照参数初始化全位于此处 //材质反光性设置 GLfloat mat_specular [] = {1.0,1.0,1.0,1.0};
openGL学习笔记三十四：光照、光源
哲学天空的博客
05-03 1180
一、 光照： 四种光照类型： 放射光（自发光） emissive : 没有光照的情况下物体自身会发射光 如：夜明珠 环境光 ambient ： 即使夜里房间灯全部关掉，还是有微弱光（月光）让你能看见房间物体轮廓，这就是环境光 漫反射光 镜面反射光 specular ： shininess 材质光泽度对比图 基本光照模型...
opengl消隐与光照
がんばれ
12-10 4366
1.      设置材料的颜色 OpenGL的光照模型根据材料反射的红、绿和蓝光的比例来模拟它的颜色。和光一样，材料也具有不同的环境、散射和镜面颜色，它们决定了材料对红、绿和蓝光的反射率。材料的环境反射属性与每种入射光的环境光成分组合，散射反射属性与入射光的散射成分组合，镜面反射属性和入射光的镜面成分组合。环境和散射属性定义了材料的颜色，它们一般很相似。               使用的函数
openGL实现太阳系行星系统
qazrui的博客
08-22 3149
openGL c++实现太阳系行星系统学习笔记
GL_AMBIENT、GL_DIFFUSE、GL_SPECULAR，GL_SHININESS，GL_EMISSION，GL_COLOR_INDEXES的区别
apuycat204023的博客
11-19 624
（1）GL_AMBIENT、GL_DIFFUSE、GL_SPECULAR属性。这三个属性与光源的三个对应属性类似，每一属性都由四个值组成。GL_AMBIENT表示各种光线照射到该材质上，经过很多次反射后最终遗留在环境中的光线强度（颜色）。GL_DIFFUSE表示光线照射到该材质上，经过漫反射后形成的光线强度（颜色）。GL_SPECULAR表示光线照射到该材质上，经过镜面反射后形成的光线强...
《OpenGL超级宝典4》学习笔记——第六章(一)
自然的专栏
02-08 1088
混合： 当混合被启用时，新颜色与颜色缓冲区中的原有颜色进行混合， glEnable(GL_BLEND); glBlendFunc(GLenum S , Glenum D); 抗锯齿： 使用混合功能来混合片段的颜色，也就是把像素的目标颜色与周围像素的颜色进行混合，   多重采样： glEnable(GL_MULTISAMPLE); glDisable(GL_MULTISAMPLE)
openGL光照系统
johncyj的专栏
11-04 535
openGL把光照系统分成了三部分：光源，材质和光照环境。（openGL没有考虑光的折射）1.      控制光源：第一个参数表示设置哪一个光源的属性，第二个参数表示设置这个光源的哪个属性，第三个参数则表示把该属性值设置为多少；               glLightfv(GL_LIGHT0, GL_POSITION, sun_light_position);GL_POSITION表示光源所处的位置，其值用（X,Y,Z,W）来表示，如果W为0的话表示光源在无    限远处，前三个值则表示了它的方向，这种
openGL编程
10-31
OPENGL编程应用与开发，适合第一次使用该编程语言的初学者使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值