lightmaterial.c

Example source codes in C++ using 3d studio max models

    cell_vector(mKe, material_Ke, 4);
    cell_vector(lmKa, lmodel_Ka, 4);
    
    glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, local_viewer.value);
    glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, two_side.value);
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmKa);
    
    glMaterialfv(GL_FRONT, GL_AMBIENT, mKa);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mKd);
    glMaterialfv(GL_FRONT, GL_SPECULAR, mKs);
    glMaterialfv(GL_FRONT, GL_EMISSION, mKe);
    glMaterialf(GL_FRONT, GL_SHININESS, material_Se.value);
    
    glLightfv(GL_LIGHT0, GL_AMBIENT, lKa);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, lKd);
    glLightfv(GL_LIGHT0, GL_SPECULAR, lKs);
    glLighti(GL_LIGHT0, GL_SPOT_EXPONENT, (int)spot_exponent.value);
    if (spot_cutoff.value > 90)
        glLighti(GL_LIGHT0, GL_SPOT_CUTOFF, 180);
    else
        glLighti(GL_LIGHT0, GL_SPOT_CUTOFF, (int)spot_cutoff.value);
    glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, Kc.value);
    glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, Kl.value);
    glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, Kq.value);
    
    l[0] = at[0] - eye[0]; 
    l[1] = at[1] - eye[1]; 
    l[2] = at[2] - eye[2];
    
    invert(modelview, inverse);
    
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    glPushMatrix();
    glMultMatrixd(inverse);
    glTranslatef(l[0], l[1], l[2]);
    glColor3fv(lKd);
    glBegin(GL_LINE_STRIP);
    if (spot_cutoff.value > 90)
        glVertex3f(0, 0, 0);
    else
        glVertex3f(pos[0]+spot_direction[0].value,
        pos[1]+spot_direction[1].value, 
        pos[2]+spot_direction[2].value);
    
    if (pos[3] == 0)        /* 10.0 = 'infinite' light */
        glVertex3f(pos[0]*10.0,pos[1]*10.0,pos[2]*10.0);
    else 
        glVertex3f(pos[0], pos[1], pos[2]);
    glEnd();
    glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, dir);
    glLightfv(GL_LIGHT0, GL_POSITION, pos);
    glPopMatrix();
    
    length = normalize(l);
    
    if (world_draw) {
        glEnable(GL_LIGHTING);
        if (pmodel)
            drawmodel();
        else 
            glutSolidTorus(0.25, 0.75, 28, 28);
        glDisable(GL_LIGHTING);
    }
    
#if 0    
#define TESS 20
    glNormal3f(0.0, 1.0, 0.0);
    for (i = 0; i < TESS; i++) {
        glBegin(GL_TRIANGLE_STRIP);
        for (j = 0; j <= TESS; j++) {
            glVertex3f(-1+(float)i/TESS*2, -1.0, -1+(float)j/TESS*2);
            glVertex3f(-1+(float)(i+1)/TESS*2, -1.0, -1+(float)j/TESS*2);
        }
        glEnd();
    }
#endif
    
    glPushMatrix();
    glMultMatrixd(inverse);
    
    /* draw the axis and eye vector */
    glPushMatrix();
    glColor3ub(0, 0, 255);
    glBegin(GL_LINE_STRIP);
    glVertex3f(0.0, 0.0, 0.0);
    glVertex3f(0.0, 0.0, -1.0*length);
    glVertex3f(0.1, 0.0, -0.9*length);
    glVertex3f(-0.1, 0.0, -0.9*length);
    glVertex3f(0.0, 0.0, -1.0*length);
    glVertex3f(0.0, 0.1, -0.9*length);
    glVertex3f(0.0, -0.1, -0.9*length);
    glVertex3f(0.0, 0.0, -1.0*length);
    glEnd();
    glColor3ub(255, 255, 0);
    glRasterPos3f(0.0, 0.0, -1.1*length);
    glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, 'e');
    glColor3ub(255, 0, 0);
    glScalef(0.4, 0.4, 0.4);
    drawaxes();
    glPopMatrix();
    
    invert(projection, inverse);
    glMultMatrixd(inverse);
    
    /* draw the viewing frustum */
    glColor3f(0.2, 0.2, 0.2);
    glBegin(GL_QUADS);
    glVertex3i(1, 1, 1);
    glVertex3i(-1, 1, 1);
    glVertex3i(-1, -1, 1);
    glVertex3i(1, -1, 1);
    glEnd();
    
    glColor3ub(128, 196, 128);
    glBegin(GL_LINES);
    glVertex3i(1, 1, -1);
    glVertex3i(1, 1, 1);
    glVertex3i(-1, 1, -1);
    glVertex3i(-1, 1, 1);
    glVertex3i(-1, -1, -1);
    glVertex3i(-1, -1, 1);
    glVertex3i(1, -1, -1);
    glVertex3i(1, -1, 1);
    glEnd();
    
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glColor4f(0.2, 0.2, 0.4, 0.5);
    glBegin(GL_QUADS);
    glVertex3i(1, 1, -1);
    glVertex3i(-1, 1, -1);
    glVertex3i(-1, -1, -1);
    glVertex3i(1, -1, -1);
    glEnd();
    glDisable(GL_BLEND);
    
    glPopMatrix();
    glutSwapBuffers();
}

void
new_material(float* material)
{
    material_Ka[0].value = material[0];
    material_Ka[1].value = material[1];
    material_Ka[2].value = material[2];
    material_Ka[3].value = material[3];
    material_Kd[0].value = material[4];
    material_Kd[1].value = material[5];
    material_Kd[2].value = material[6];
    material_Kd[3].value = material[7];
    material_Ks[0].value = material[8];
    material_Ks[1].value = material[9];
    material_Ks[2].value = material[10];
    material_Ks[3].value = material[11];
    material_Ke[0].value = 0;
    material_Ke[1].value = 0;
    material_Ke[2].value = 0;
    material_Ke[3].value = 0;
    material_Se.value = material[12];
}

void
world_menu(int value)
{
    switch (value) {
    case 1:
        new_material(Brass);
        break;
    case 2:
        new_material(Bronze);
        break;
    case 3:
        new_material(Polished_Bronze);
        break;
    case 4:
        new_material(Chrome);
        break;
    case 5:
        new_material(Copper);
        break;
    case 6:
        new_material(Polished_Copper);
        break;
    case 7:
        new_material(Gold);
        break;
    case 8:
        new_material(Polished_Gold);
        break;
    case 9:
        new_material(Pewter);
        break;
    case 10:
        new_material(Silver);
        break;
    case 11:
        new_material(Polished_Silver);
        break;
    case 12:
        new_material(Emerald);
        break;
    case 13:
        new_material(Jade);
        break;
    case 14:
        new_material(Obsidian);
        break;
    case 15:
        new_material(Pearl);
        break;
    case 16:
        new_material(Ruby);
        break;
    case 17:
        new_material(Turquoise);
        break;
    case 18:
        new_material(Black_Plastic);
        break;
    case 19:
        new_material(Black_Rubber);
        break;
    }
    
    redisplay_all();
}

void
screen_reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60.0, (float)width/height, 0.5, 8.0);
    glGetDoublev(GL_PROJECTION_MATRIX, projection);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(eye[0], eye[1], eye[2], at[0], at[1], at[2], up[0], up[1],up[2]);
    glClearColor(0.2, 0.2, 0.2, 1.0);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
}

void
screen_display(void)
{
    GLfloat pos[4], lKa[4], lKd[4], lKs[4];
    GLfloat dir[3], mKa[4], mKd[4], mKs[4], mKe[4];
    GLfloat lmKa[4];
    
    cell_vector(pos, light_pos, 4);
    cell_vector(lKa, light_Ka, 4);
    cell_vector(lKd, light_Kd, 4);
    cell_vector(lKs, light_Ks, 4);
    cell_vector(dir, spot_direction, 3);
    cell_vector(mKa, material_Ka, 4);
    cell_vector(mKd, material_Kd, 4);
    cell_vector(mKs, material_Ks, 4);
    cell_vector(mKe, material_Ke, 4);
    cell_vector(lmKa, lmodel_Ka, 4);
    
    glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, local_viewer.value);
    glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, two_side.value);
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmKa);
    
    glLightfv(GL_LIGHT0, GL_POSITION, pos);
    glLightfv(GL_LIGHT0, GL_AMBIENT, lKa);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, lKd);
    glLightfv(GL_LIGHT0, GL_SPECULAR, lKs);
    glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, dir);
    glLighti(GL_LIGHT0, GL_SPOT_EXPONENT, (int)spot_exponent.value);
    if (spot_cutoff.value > 90)
        glLighti(GL_LIGHT0, GL_SPOT_CUTOFF, 180);
    else
        glLighti(GL_LIGHT0, GL_SPOT_CUTOFF, (int)spot_cutoff.value);
    glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, Kc.value);
    glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, Kl.value);
    glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, Kq.value);
    
    glMaterialfv(GL_FRONT, GL_AMBIENT, mKa);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mKd);
    glMaterialfv(GL_FRONT, GL_SPECULAR, mKs);
    glMaterialfv(GL_FRONT, GL_EMISSION, mKe);
    glMaterialf(GL_FRONT, GL_SHININESS, material_Se.value);
    
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glPushMatrix();
    glRotatef(spin_y, 1.0, 0.0, 0.0);
    glRotatef(spin_x, 0.0, 1.0, 0.0);
    glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
    if (pmodel)
        drawmodel();
    else 
        glutSolidTorus(0.25, 0.75, 28, 28);
    glPopMatrix();
    
#if 0    
#define TESS 20
    glNormal3f(0.0, 1.0, 0.0);
    for (i = 0; i < TESS; i++) {
        glBegin(GL_TRIANGLE_STRIP);
        for (j = 0; j <= TESS; j++) {
            glVertex3f(-1+(float)i/TESS*2, -1.0, -1+(float)j/TESS*2);
            glVertex3f(-1+(float)(i+1)/TESS*2, -1.0, -1+(float)j/TESS*2);
        }
        glEnd();
    }
#endif
    
    glutSwapBuffers();
}

void
screen_menu(int value)
{
    char* name = 0;
    
    switch (value) {
    case 'a':
        name = "data/al.obj";
        break;
    case 's':
        name = "data/soccerball.obj";
        break;
    case 'd':
        name = "data/dolphins.obj";
        break;
    case 'f':
        name = "data/flowers.obj";
        break;
    case 'j':
        name = "data/f-16.obj";
        break;
    case 'p':
        name = "data/porsche.obj";
        break;
    case 'r':
        name = "data/rose+vase.obj";
        break;
    case 'n':
        if (pmodel) glmDelete(pmodel);
        pmodel = NULL;
        redisplay_all();
        return;
    }
    
    if (name) {
        if (pmodel) glmDelete(pmodel);
        pmodel = glmReadOBJ(name);
        if (!pmodel) exit(0);
        glmUnitize(pmodel);
        glmFacetNormals(pmodel);
        glmVertexNormals(pmodel, 90.0);
    }
    
    redisplay_all();
}

int old_x, old_y;

void
screen_mouse(int button, int state, int x, int y)
{
    old_x = x;
    old_y = y;
    
    redisplay_all();
}

void
screen_motion(int x, int y)
{
    spin_x = x - old_x;
    spin_y = y - old_y;
    
    redisplay_all();
}

void
command_reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, width, height, 0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glClearColor(0.0, 0.0, 0.0, 0.0);
}

void
lighting_display(void)
{
    setfont("helvetica", 18);
    drawstr(10, light_pos[0].y, "GLfloat light_pos[ ] = {");
    drawstr(10, light_Ka[0].y, "GLfloat light_Ka[ ] = {");
    drawstr(10, light_Kd[0].y, "GLfloat light_Kd[ ] = {");
    drawstr(10, light_Ks[0].y, "GLfloat light_Ks[ ] = {");
    drawstr(light_pos[0].x+50, light_pos[0].y, ",");
    drawstr(light_pos[1].x+50, light_pos[1].y, ",");
    drawstr(light_pos[2].x+50, light_pos[2].y, ",");
    drawstr(light_pos[3].x+50, light_pos[3].y, "};");
    drawstr(light_Ka[0].x+50, light_Ka[0].y, ",");
    drawstr(light_Ka[1].x+50, light_Ka[1].y, ",");
    drawstr(light_Ka[2].x+50, light_Ka[2].y, ",");
    drawstr(light_Ka[3].x+50, light_Ka[3].y, "};");
    drawstr(light_Kd[0].x+50, light_Kd[0].y, ",");
    drawstr(light_Kd[1].x+50, light_Kd[1].y, ",");
    drawstr(light_Kd[2].x+50, light_Kd[2].y, ",");
    drawstr(light_Kd[3].x+50, light_Kd[3].y, "};");
    drawstr(light_Ks[0].x+50, light_Ks[0].y, ",");
    drawstr(light_Ks[1].x+50, light_Ks[1].y, ",");
    drawstr(light_Ks[2].x+50, light_Ks[2].y, ",");
    drawstr(light_Ks[3].x+50, light_Ks[3].y, "};");
    
    setfont("helvetica", 12);
    drawstr(10, light_Ks[0].y+30,
        "glLightfv(GL_LIGHT0, GL_POSITION, light_pos);");
    drawstr(10, light_Ks[1].y+50,
        "glLightfv(GL_LIGHT0, GL_AMBIENT, light_Ka);");
    drawstr(10, light_Ks[2].y+70,
        "glLightfv(GL_LIGHT0, GL_DIFFUSE, light_Kd);");
    drawstr(10, light_Ks[3].y+90,
        "glLightfv(GL_LIGHT0, GL_SPECULAR, light_Ks);");
    
    setfont("helvetica", 18);
    
    cell_draw(&light_pos[0]);
    cell_draw(&light_pos[1]);
    cell_draw(&light_pos[2]);
    cell_draw(&light_pos[3]);
    
    cell_draw(&light_Ka[0]);
    cell_draw(&light_Ka[1]);
    cell_draw(&light_Ka[2]);
    cell_draw(&light_Ka[3]);
    
    cell_draw(&light_Kd[0]);
    cell_draw(&light_Kd[1]);
    cell_draw(&light_Kd[2]);
    cell_draw(&light_Kd[3]);
    
    cell_draw(&light_Ks[0]);
    cell_draw(&light_Ks[1]);
    cell_draw(&light_Ks[2]);
    cell_draw(&light_Ks[3]);
    
    glColor3ub(255, 255, 255);
}

void
spotlight_display(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    glColor3ub(255, 255, 255);
    
    lighting_display();
    
    setfont("helvetica", 18);
    drawstr(10, spot_direction[0].y, "GLfloat spot_direction[ ] = {");
    drawstr(10, spot_exponent.y, "GLint spot_exponent =                 "
        "spot_cutoff =   ");
    drawstr(spot_direction[0].x+50, spot_direction[0].y, ",");
    drawstr(spot_direction[1].x+50, spot_direction[1].y, ",");
    drawstr(spot_direction[2].x+50, spot_direction[2].y, "};");
    drawstr(spot_exponent.x+40, spot_cutoff.y, ",");
    drawstr(spot_cutoff.x+40, spot_cutoff.y, ";");
    
    setfont("helvetica", 12);
    drawstr(10, spot_cutoff.y+30,
        "glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, spot_direction);");
    drawstr(10, spot_cutoff.y+50,
        "glLighti(GL_LIGHT0, GL_SPOT_EXPONENT, spot_exponent);");