2005-11-03

About HW3

Color-Index mode

• What to store in the bitplane
For RGBA mode: store RGBA intenstive values.

For Color-index mode: store color index (wrt. Color LookUpTable).

• Color LookUp Table
aka. "Color Map"

Index	Red	Green	Blue
0
1
2
3
.
.
255



• Number of available colors in the same time is limited by the size of the Color LUT.
The table's size is always a power of 2.( 256(2⁸) or 4096(2¹², for example)
• When to use color-index mode?
• Porting old color-index mode applications
• HW/SW constraints on the number of bitplanes
• Color-map animation
• But, in general, use RGBA mode wherever possible.

Related APIs

void glIndex{ sifd ub} ( TYPE c );
void glIndex{ sifd ub}v ( const TYPE *c );  

void glClearIndex ( GLfloat cindex );

Setup color map (related to Window system):
void glutSetColor( int cell, GLfloat red, GLfloat green, GLfloat blue );

        

A trick to avoid strange coloring in 'smooth shading' mode

For example, build a 32 continous color indices with slightly differing shades of 'yellow'. for ( i = 0; i < 32; i++ ) { glutSetColor ( 16+i, 1.0*(i/32.0), 1.0*(i/32.0), 0.0); }

Chapter 5: Lighting

• Lighting is important

• Give more visual feeling about curvature and depth
• Makes 3D apparent in graphics images

Hidden-surface removal

• In lighting and shading, depth info and normal vectors become very important
• Consider the old painter's algorithm

while (1) { get_viewing_point_from_mouse_position(); glClear(GL_COLOR_BUFFER_BIT); draw_3d_object_A(); draw_3d_object_B(); }

• One object might obscure the other

• Hidden-surface removal works with using Z-buffer (depth-buffer)
• Example

glutInitDisplayMode ( GLUT_DEPTH | ... ); glEnable ( GL_DEPTH_TEST ); ... while(1) { glClear( GLCOLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); get_viewing_point_from_mouse_position(); draw_3d_object_A(); draw_3d_object_B(); }

Lighting components

• Ambient
Light arrives equally from all directions. In fact, light scatters so much that we cannot determine its orientation.



• Diffuse
Light from a point source that will be reflected diffusely ( i.e. refelected evenly in all directions away from the surface )





• Specular
Light from a point source that will be reflected specularly ( i.e. reflected in a mirror-like fashion, as from a shinny surface )





• Emissive
The emissivity of a surface controls how much light the surface emits in the absence of any incident light. Light emitted from a surface does not act as light source that illuminates other surfaces; instead, it only affects the color seen by the observer
• Multiple light components result

RGB values for lights and materials properties

• RGB values for light and material have different meanings
• For light: light colors(intensities)
(R, G, B) = (1, 1, 0) -> yellow light
• For material: reflected proportions
(R, G, B) = (1, 0.5, 0) -> the material reflects all the incoming red light, half the incoming green light, and nonn of the incoming blue light.

• ( LR*MR, LG*MG, LB*MB )
• Multiple light source: Light₁ + Light₂
( R1+R2, G1+G2, B1+B2 )
• If the result is greater than 1.0, clamp to 1.0

A lighting example overview

• Define normal vectors for each vertex of all the objects. These normals determine the orientation of the object relative to the light sources. ( In our example, the normals are defined as part of the glutSolidSphere() )
  • Needs unit normal vector
  • void glEnable(GL_NORMALIZE)
  • void glEnable(GL_RESCALE_NORMAL)

• Create, select, and position one or more light sources.
You can create up to 8 different light sources(GL_LIGHT0 to GL_LIGHT7). But more lights also means more computation complexity.
• Create and select a lighting model, which defines the level of global ambient light and the effective location of the viewpoint (for the purposes of lighting calculations).
• Define material properties for the objects in the scene.

#include #include /* Initialize material property, light source, lighting model, * and depth buffer. */ void init(void) { GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat mat_shininess[] = { 50.0 }; GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 }; GLfloat light[] = { 1.0, 0.2, 0.2 }; GLfloat lmodel_ambient[] = { 0.1, 0.1, 0.1, 1.0 }; glClearColor (0.0, 0.0, 0.0, 0.0); glShadeModel (GL_SMOOTH); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glLightfv(GL_LIGHT0, GL_DIFFUSE, light ); glLightfv(GL_LIGHT0, GL_SPECULAR, light ); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); } 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(); } 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); glutMainLoop(); return 0; }

Lighting APIs

Attenuation (define how the intensities of light decay)

For real-world lights, the intensity of light decreases as distance from the light increases. Since a directional light is infinitely far away, it doesn't make sense to attenuate its intensity over distance, so attenuation is disabled for a directional light. However, you might want to attenuate the light from a positional light. OpenGL attenuates a light source by multiplying the contribution of that source by an attenuation factor:

attenuation factor =

1             kc + kld + kqd2

where

d = distance between the light's position and the vertex

kc = GL_CONSTANT_ATTENUATION

kl = GL_LINEAR_ATTENUATION

kq = GL_QUADRATIC_ATTENUATION

By default, k_c = 1.0, k_l = k_q = 0.0.
You can give these parameters different values:

glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 2.0); glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 1.0); glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.5);

Spotlights ( default GL_SPOT_CUTOFF=180 )

glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 45.0); GLfloat spot_direction[] = { -1.0, -1.0, 0.0 }; glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, spot_direction);

Multiple lights

Can have up to 8 light sources.

Example: Second light source

GLfloat light1_ambient[] = { 0.2, 0.2, 0.2, 1.0 }; GLfloat light1_diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light1_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light1_position[] = { -2.0, 2.0, 1.0, 1.0 }; GLfloat spot_direction[] = { -1.0, -1.0, 0.0 }; glLightfv(GL_LIGHT1, GL_AMBIENT, light1_ambient); glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse); glLightfv(GL_LIGHT1, GL_SPECULAR, light1_specular); glLightfv(GL_LIGHT1, GL_POSITION, light1_position); glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 1.5); glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.5); glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.2); glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 45.0); glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, spot_direction); glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, 2.0); glEnable(GL_LIGHT1);

Position

• directional light -- source is infinitely away ( let w = 0 )
  GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
  glLightfv(GL_LIGHT0, GL_POSITION, light_position);

  The fourth component of light_position is 0.0 which signifies the light is directional light.
  By default, GL_POSITION is (0, 0, 1, 0), which defines a directional light. And (x, y, z) is its direction.

• positional light -- source at a finite distance ( w is not 0 )

  GLfloat light_position[] = { 5.0, 10.0, 2.0, 1.0 }; glLightfv(GL_LIGHT0, GL_POSITION, light_position);

  The location is transformed by the model view matrix and stored in the eye coordinate system (i.e. relative to the eye )
  Note that by default (i.e. gluLookAt() is not called ), the camera ( eye ) is situated at the origin, pointing down the negative z-axis.
  By default, a positional light radiates in all directions.

• Fixed light
In init() and reshape()

glViewport (0, 0, (GLsizei) w, (GLsizei) h); glMatrixMode (GL_PROJECTION); glLoadIdentity(); if (w <= h) glOrtho (-1.5, 1.5, -1.5*h/w, 1.5*h/w, -10.0, 10.0); else glOrtho (-1.5*w/h, 1.5*w/h, -1.5, 1.5, -10.0, 10.0); glMatrixMode (GL_MODELVIEW); glLoadIdentity(); /* later in init() */ GLfloat light_position[] = { 1.0, 1.0, 1.0, 1.0 }; glLightfv(GL_LIGHT0, GL_POSITION, position);

• Independently Moving the Light

To rotate or translate the light position: light moves relative to a stationary object.


static GLdouble spin; void display(void) { GLfloat light_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(spin, 1.0, 0.0, 0.0); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glPopMatrix(); glutSolidTorus (0.275, 0.85, 8, 15); glPopMatrix(); glFlush(); }

Example 6-6. Moving a Light with Modeling Transformations: movelight.c




#include <GL/gl.h> #include <GL/glu.h> #include “glut.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); } /* Here is where the light position is reset after the modeling * transformation (glRotated) is called. This places the * light at a new position in world coordinates. The cube * represents the position of the light. */ void display(void) { GLfloat position[] = { 0.0, 0.0, 1.5, 1.0 }; glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix (); glTranslatef (0.0, 0.0, -5.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; } } 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); glutMainLoop(); return 0; }



• Moving the Light Source Together with Your Viewpoint
• To create a light that moves along with the viewpoint, you need to set the light position before the viewing transformation.
• Then the viewing transformation affects both the light and the viewpoint in the same way.
• Remember that the light position is stored in eye coordinates

Light Source That Moves with the Viewpoint

GLfloat light_position() = { 0.0, 0.0, 0.0, 1.0 }; glViewport(0, 0, (GLint) w, (GLint) h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(40.0, (GLfloat) w/(GLfloat) h, 1.0, 100.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glLightfv(GL_LIGHT0, GL_POSITION, light_position);

If the viewpoint is now moved, the light will move along with it, maintaining (0, 0, 0) distance, relative to the eye.

static GLdouble ex, ey, ez, upx, upy, upz; void display(void) { glClear(GL_COLOR_BUFFER_MASK | GL_DEPTH_BUFFER_MASK); glPushMatrix(); gluLookAt (ex, ey, ez, 0.0, 0.0, 0.0, upx, upy, upz); glutSolidTorus (0.275, 0.85, 8, 15); glPopMatrix(); glFlush(); }

---

Julian Yu-Chung Chen
Last modified: Wed Sep 07 17:40:25 CDT 2005