lightmaterial.c

计算机图形学～想必是很多人需要的～在此共享一下

/*
    lightmaterial.c
    Nate Robins, 1997

    Tool for teaching about OpenGL lighting & material properties.
    
*/


#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <GL/glut.h>
#include "glm.h"
#include "materials.h"

#pragma comment( linker, "/entry:\"mainCRTStartup\"" )  // set the entry point to be main()


typedef struct _cell {
    int id;
    int x, y;
    float min, max;
    float value;
    float step;
    char* info;
    char* format;
} cell;


cell light_pos[4] = {
    { 1, 210, 30, -5.0, 5.0, -2.0, 0.01,
        "Specifies X coordinate of light vector.", "%.2f" },
    { 2, 270, 30, -5.0, 5.0, 2.0, 0.01,
    "Specifies Y coordinate of light vector.", "%.2f" },
    { 3, 330, 30, -5.0, 5.0, 2.0, 0.01,
    "Specifies Z coordinate of light vector.", "%.2f" },
    { 4, 390, 30, 0.0, 1.0, 1.0, 1.0,
    "Specifies directional (0) or positional (1) light.", "%.2f" },
};

cell light_Ka[4] = {
    { 5, 200, 60, 0.0, 1.0, 0.0, 0.01,
        "Specifies ambient red intensity of the light.", "%.2f" },
    { 6, 260, 60, 0.0, 1.0, 0.0, 0.01,
    "Specifies ambient green intensity of the light.", "%.2f" },
    { 7, 320, 60, 0.0, 1.0, 0.0, 0.01,
    "Specifies ambient blue intensity of the light.", "%.2f" },
    { 8, 380, 60, 0.0, 1.0, 1.0, 0.01,
    "Specifies ambient alpha intensity of the light.", "%.2f" },
};

cell light_Kd[4] = {
    {  9, 200, 90, 0.0, 1.0, 1.0, 0.01,
        "Specifies diffuse red intensity of the light.", "%.2f" },
    { 10, 260, 90, 0.0, 1.0, 1.0, 0.01,
    "Specifies diffuse green intensity of the light.", "%.2f" },
    { 11, 320, 90, 0.0, 1.0, 1.0, 0.01,
    "Specifies diffuse blue intensity of the light.", "%.2f" },
    { 12, 380, 90, 0.0, 1.0, 1.0, 0.01,
    "Specifies diffuse alpha intensity of the light.", "%.2f" },
};

cell light_Ks[4] = {
    { 13, 200, 120, 0.0, 1.0, 1.0, 0.01,
        "Specifies specular red intensity of the light.", "%.2f" },
    { 14, 260, 120, 0.0, 1.0, 1.0, 0.01,
    "Specifies specular green intensity of the light.", "%.2f" },
    { 15, 320, 120, 0.0, 1.0, 1.0, 0.01,
    "Specifies specular blue intensity of the light.", "%.2f" },
    { 16, 380, 120, 0.0, 1.0, 1.0, 0.01,
    "Specifies specular alpha intensity of the light.", "%.2f" },
};

cell spot_direction[3] = {
    { 17, 250, 260, -1.0, 1.0, 1.0, 0.01,
        "Specifies X coordinate of spotlight direction vector.", "%.2f" },
    { 18, 310, 260, -1.0, 1.0, -1.0, 0.01,
    "Specifies Y coordinate of spotlight direction vector.", "%.2f" },
    { 19, 370, 260, -1.0, 1.0, -1.0, 0.01,
    "Specifies Z coordinate of spotlight direction vector.", "%.2f" },
};

cell spot_exponent = { 20, 210, 290, 0.0, 128.0, 30.0, 1.0,
"Specifies intensity distribution of spotlight.", "%.0f" };
cell spot_cutoff = { 21, 410, 290, 0.0, 91.0, 91.0, 1.0,
"Specifies maximum spread angle of spotlight (180 = off).", "%.0f" };

cell Kc = { 22, 120, 410, 0.0, 5.0, 1.0, 0.01,
"Specifies constant attenuation factor.", "%.2f" };
cell Kl = { 23, 215, 410, 0.0, 5.0, 0.0, 0.01,
"Specifies linear attenuation factor.", "%.2f" };
cell Kq = { 24, 315, 410, 0.0, 5.0, 0.0, 0.01,
"Specifies quadratic attenuation factor.", "%.2f" };

cell material_Ka[4] = {
    { 25, 220, 260, 0.0, 1.0, 0.2, 0.01,
        "Specifies ambient red reflectance of the material.", "%.2f" },
    { 26, 280, 260, 0.0, 1.0, 0.2, 0.01,
    "Specifies ambient green reflectance of the material.", "%.2f" },
    { 27, 340, 260, 0.0, 1.0, 0.2, 0.01,
    "Specifies ambient blue reflectance of the material.", "%.2f" },
    { 28, 400, 260, 0.0, 1.0, 1.0, 0.01,
    "Specifies ambient alpha reflectance of the material.", "%.2f" },
};

cell material_Kd[4] = {
    { 29, 220, 290, 0.0, 1.0, 0.8, 0.01,
        "Specifies diffuse red reflectance of the material.", "%.2f" },
    { 30, 280, 290, 0.0, 1.0, 0.8, 0.01,
    "Specifies diffuse green reflectance of the material.", "%.2f" },
    { 31, 340, 290, 0.0, 1.0, 0.8, 0.01,
    "Specifies diffuse blue reflectance of the material.", "%.2f" },
    { 32, 400, 290, 0.0, 1.0, 1.0, 0.01,
    "Specifies diffuse alpha reflectance of the material.", "%.2f" },
};

cell material_Ks[4] = {
    { 33, 220, 320, 0.0, 1.0, 1.0, 0.01,
        "Specifies specular red reflectance of the material.", "%.2f" },
    { 34, 280, 320, 0.0, 1.0, 1.0, 0.01,
    "Specifies specular green reflectance of the material.", "%.2f" },
    { 35, 340, 320, 0.0, 1.0, 1.0, 0.01,
    "Specifies specular blue reflectance of the material.", "%.2f" },
    { 36, 400, 320, 0.0, 1.0, 1.0, 0.01,
    "Specifies specular alpha reflectance of the material.", "%.2f" },
};

cell material_Ke[4] = {
    { 37, 220, 350, 0.0, 1.0, 0.0, 0.01,
        "Specifies red emitted light intensity of the material.", "%.2f" },
    { 38, 280, 350, 0.0, 1.0, 0.0, 0.01,
    "Specifies green emitted light intensity of the material.", "%.2f" },
    { 39, 340, 350, 0.0, 1.0, 0.0, 0.01,
    "Specifies blue emitted light intensity of the material.", "%.2f" },
    { 40, 400, 350, 0.0, 1.0, 1.0, 0.01,
    "Specifies alpha emitted light intensity of the material.", "%.2f" },
};

cell material_Se = { 41, 200, 380, 0.0, 128.0, 50.0, 1.0,
"Specifies the specular exponent of the material.", "%.0f" };

cell lmodel_Ka[4] = {
    { 42, 220, 260, 0.0, 1.0, 0.2, 0.01,
        "Specifies ambient red intensity of the entire scene.", "%.2f" },
    { 43, 280, 260, 0.0, 1.0, 0.2, 0.01,
    "Specifies ambient green intensity of the entire scene.", "%.2f" },
    { 44, 340, 260, 0.0, 1.0, 0.2, 0.01,
    "Specifies ambient blue intensity of the entire scene.", "%.2f" },
    { 45, 400, 260, 0.0, 1.0, 1.0, 0.01,
    "Specifies ambient alpha intensity of the entire scene.", "%.2f" },
};

cell local_viewer = { 46, 460, 340, 0.0, 1.0, 0.0, 1.0,
"Specifies infinite (0.0) or local (1.0) light model.", "%.1f" };

cell two_side = { 47, 415, 390, 0.0, 1.0, 0.0, 1.0,
"Specifies one (0.0) or two (1.0) sided lighting.", "%.1f" };


GLfloat eye[3] = { 0.0, 0.0, 3.0 };
GLfloat at[3]  = { 0.0, 0.0, 0.0 };
GLfloat up[3]  = { 0.0, 1.0, 0.0 };

GLboolean world_draw = GL_TRUE;
GLMmodel* pmodel = NULL;
GLint selection = 0;
GLfloat spin_x = 0.0;
GLfloat spin_y = 0.0;

void redisplay_all(void);
GLdouble projection[16], modelview[16], inverse[16];
GLuint window, world, screen, command;
GLuint sub_width = 256, sub_height = 256;



GLvoid *font_style = GLUT_BITMAP_TIMES_ROMAN_10;

void
setfont(char* name, int size)
{
    font_style = GLUT_BITMAP_HELVETICA_10;
    if (strcmp(name, "helvetica") == 0) {
        if (size == 12) 
            font_style = GLUT_BITMAP_HELVETICA_12;
        else if (size == 18)
            font_style = GLUT_BITMAP_HELVETICA_18;
    } else if (strcmp(name, "times roman") == 0) {
        font_style = GLUT_BITMAP_TIMES_ROMAN_10;
        if (size == 24)
            font_style = GLUT_BITMAP_TIMES_ROMAN_24;
    } else if (strcmp(name, "8x13") == 0) {
        font_style = GLUT_BITMAP_8_BY_13;
    } else if (strcmp(name, "9x15") == 0) {
        font_style = GLUT_BITMAP_9_BY_15;
    }
}

void 
drawstr(GLuint x, GLuint y, char* format, ...)
{
    va_list args;
    char buffer[255], *s;
    
    va_start(args, format);
    vsprintf(buffer, format, args);
    va_end(args);
    
    glRasterPos2i(x, y);
    for (s = buffer; *s; s++)
        glutBitmapCharacter(font_style, *s);
}

void
cell_draw(cell* cell)
{
    glColor3ub(0, 255, 128);
    if (selection == cell->id) {
        glColor3ub(255, 255, 0);
        drawstr(10, 525, cell->info);
        glColor3ub(255, 0, 0);
    }
    
    if (cell->id == 21 && cell->value > 90.0) /* treat cutoff specially */
        drawstr(cell->x, cell->y, cell->format, 180.0);
    else 
        drawstr(cell->x, cell->y, cell->format, cell->value);
}

int
cell_hit(cell* cell, int x, int y)
{
    if (x > cell->x && x < cell->x+60 &&
        y > cell->y-20 && y < cell->y+10)
        return cell->id;
    return 0;
}

void
cell_update(cell* cell, int update)
{
    if (selection != cell->id)
        return;
    
    cell->value += update * cell->step;
    
    if (cell->value < cell->min)
        cell->value = cell->min;
    else if (cell->value > cell->max) 
        cell->value = cell->max;
    
}

void
cell_vector(float* dst, cell* cell, int num)
{
    while (--num >= 0)
        dst[num] = cell[num].value;
}

void
drawmodel(void)
{
    if (!pmodel) {
        pmodel = glmReadOBJ("data/soccerball.obj");
        if (!pmodel) exit(0);
        glmUnitize(pmodel);
        glmFacetNormals(pmodel);
        glmVertexNormals(pmodel, 90.0);
    }
    
    glmDraw(pmodel, GLM_SMOOTH);
}

void
drawaxes(void)
{
    glColor3ub(255, 0, 0);
    glBegin(GL_LINE_STRIP);
    glVertex3f(0.0, 0.0, 0.0);
    glVertex3f(1.0, 0.0, 0.0);
    glVertex3f(0.75, 0.25, 0.0);
    glVertex3f(0.75, -0.25, 0.0);
    glVertex3f(1.0, 0.0, 0.0);
    glVertex3f(0.75, 0.0, 0.25);
    glVertex3f(0.75, 0.0, -0.25);
    glVertex3f(1.0, 0.0, 0.0);
    glEnd();
    glBegin(GL_LINE_STRIP);
    glVertex3f(0.0, 0.0, 0.0);
    glVertex3f(0.0, 1.0, 0.0);
    glVertex3f(0.0, 0.75, 0.25);
    glVertex3f(0.0, 0.75, -0.25);
    glVertex3f(0.0, 1.0, 0.0);
    glVertex3f(0.25, 0.75, 0.0);
    glVertex3f(-0.25, 0.75, 0.0);
    glVertex3f(0.0, 1.0, 0.0);
    glEnd();
    glBegin(GL_LINE_STRIP);
    glVertex3f(0.0, 0.0, 0.0);
    glVertex3f(0.0, 0.0, 1.0);
    glVertex3f(0.25, 0.0, 0.75);
    glVertex3f(-0.25, 0.0, 0.75);
    glVertex3f(0.0, 0.0, 1.0);
    glVertex3f(0.0, 0.25, 0.75);
    glVertex3f(0.0, -0.25, 0.75);
    glVertex3f(0.0, 0.0, 1.0);
    glEnd();
    
    glColor3ub(255, 255, 0);
    glRasterPos3f(1.1, 0.0, 0.0);
    glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, 'x');
    glRasterPos3f(0.0, 1.1, 0.0);
    glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, 'y');
    glRasterPos3f(0.0, 0.0, 1.1);
    glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, 'z');
}

void
identity(GLdouble m[16])
{
    m[0+4*0] = 1; m[0+4*1] = 0; m[0+4*2] = 0; m[0+4*3] = 0;
    m[1+4*0] = 0; m[1+4*1] = 1; m[1+4*2] = 0; m[1+4*3] = 0;
    m[2+4*0] = 0; m[2+4*1] = 0; m[2+4*2] = 1; m[2+4*3] = 0;
    m[3+4*0] = 0; m[3+4*1] = 0; m[3+4*2] = 0; m[3+4*3] = 1;
}

GLboolean
invert(GLdouble src[16], GLdouble inverse[16])
{
    double t;
    int i, j, k, swap;
    GLdouble tmp[4][4];
    
    identity(inverse);
    
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            tmp[i][j] = src[i*4+j];
        }
    }
    
    for (i = 0; i < 4; i++) {
        /* look for largest element in column. */
        swap = i;
        for (j = i + 1; j < 4; j++) {
            if (fabs(tmp[j][i]) > fabs(tmp[i][i])) {
                swap = j;
            }
        }
        
        if (swap != i) {
            /* swap rows. */
            for (k = 0; k < 4; k++) {
                t = tmp[i][k];
                tmp[i][k] = tmp[swap][k];
                tmp[swap][k] = t;
                
                t = inverse[i*4+k];
                inverse[i*4+k] = inverse[swap*4+k];
                inverse[swap*4+k] = t;
            }
        }
        
        if (tmp[i][i] == 0) {
        /* no non-zero pivot.  the matrix is singular, which
           shouldn't happen.  This means the user gave us a bad
            matrix. */
            return GL_FALSE;
        }
        
        t = tmp[i][i];
        for (k = 0; k < 4; k++) {
            tmp[i][k] /= t;
            inverse[i*4+k] /= t;
        }
        for (j = 0; j < 4; j++) {
            if (j != i) {
                t = tmp[j][i];
                for (k = 0; k < 4; k++) {
                    tmp[j][k] -= tmp[i][k]*t;
                    inverse[j*4+k] -= inverse[i*4+k]*t;
                }
            }
        }
    }
    return GL_TRUE;
}

float
normalize(float* v)
{
    float length;
    
    length = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
    v[0] /= length;
    v[1] /= length;
    v[2] /= length;
    
    return length;
}

void
main_reshape(int width,  int height) 
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, width, height, 0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    
#define GAP  25             /* gap between subwindows */
    sub_width = (width-GAP*3)/3;
    sub_height = (height-GAP*3)/2;
    
    glutSetWindow(screen);
    glutPositionWindow(GAP, GAP);
    glutReshapeWindow(sub_width, sub_height);
    glutSetWindow(world);
    glutPositionWindow(GAP, GAP+sub_height+GAP);
    glutReshapeWindow(sub_width, sub_height);
    glutSetWindow(command);
    glutPositionWindow(GAP+sub_width+GAP, GAP);
    glutReshapeWindow(sub_width*2, sub_height*2+GAP);
}

void
main_display(void)
{
    glClearColor(0.8, 0.8, 0.8, 0.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glColor3ub(0, 0, 0);
    setfont("helvetica", 12);
    drawstr(GAP, GAP-5, "Screen-space view");
    drawstr(GAP+sub_width+GAP, GAP-5, "Command manipulation window");
    drawstr(GAP, GAP+sub_height+GAP-5, "World-space view");
    glutSwapBuffers();
}

void
world_reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60.0, (GLfloat)width/height, 0.01, 256.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.0, 0.0, -6.0);
    glRotatef(-45.0, 0.0, 1.0, 0.0);
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glEnable(GL_DEPTH_TEST);
    glDisable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
}

void
world_display(void)
{
    double length;
    float l[3];
    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);