View difference between Paste ID: zZ2EDe1S and JQzGr1Rk

 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
 #include <sys/time.h>
 
 #define GL_GLEXT_PROTOTYPES
 #include <GL/gl.h>
 #include <GL/glu.h>
 #include <GL/glut.h>
 
 float light_position[4]  = {0.5, 0.5, 1.0, 1.0};
 float light_ambient [4]  = {0.0, 0.0, 0.0, 1.0};
 float light_diffuse [4]  = {1.0, 1.0, 1.0, 1.0};
 float light_specular[4]  = {1.0, 1.0, 1.0, 1.0};
 
 float lightFOV_ = 90.0;
 float lightNear_ = 0.1;
 float lightFar_ = 20.0;
 
 float material_emission[4]  = {0.0, 0.0, 0.0, 1.0};
 float material_ambient [4]  = {0.2, 0.6, 0.2, 1.0};
 float material_diffuse [4]  = {0.2, 0.6, 0.2, 1.0};
 float material_specular[4]  = {0.3, 0.3, 0.3, 1.0};
 float material_shininess = 50.0;
 
 float object_position[4] = {0.0, 0.0, -2.0, 1.0};
 float object_rotation[4] = {-20.0, 0.0, 0.0, 1.0};
 
 #define W 512
 #define H 512
 
 #define R 20
 #define N (2 * R + 1)
 
 GLuint indices[N-1][N-1][4];
 
-float lightPos_[4] = {0.5, 0.5, 1.0, 1.0};
+enum key_state {
     DOWN = 1,
     CTRL = 2,
     SHIFT = 3
 };
 
 int width = 1;
 int height = 1;
 int key_state[0x100];
 double last = -1.0;
 
 float lightPos_[4];
 float objectPos_[4];
 float objectRot_[4];
 
-	    float z = k / d - 2.0;
+
 
 void make_data(void)
 {
     float k = 0.1;
 
     static float verts[N][N][3];
     static float norms[N][N][3];
     for (int j = 0; j < N; j++) {
 	for (int i = 0; i < N; i++) {
 	    float x = 1.5 * (i / (float) R - 1.0);
 	    float y = 1.5 * (j / (float) R - 1.0);
 	    float d = x * x + y * y + k;
 	    float z = k / d;
 	    verts[j][i][0] = x;
 	    verts[j][i][1] = y;
 	    verts[j][i][2] = z;
 	    float d2 = d * d;
 	    float dx = 2 * k * x / d2;
 	    float dy = 2 * k * y / d2;
 	    float dz = 1.0;
 	    float m = sqrt(dx * dx + dy * dy + dz * dz);
 	    norms[j][i][0] = dx / m;
 	    norms[j][i][1] = dy / m;
 	    norms[j][i][2] = dz / m;
 	}
     }
 
     glVertexPointer(3, GL_FLOAT, 0, (const GLvoid *) verts);
     glNormalPointer(GL_FLOAT, 0, (const GLvoid *) norms);
     glEnableClientState(GL_VERTEX_ARRAY);
     glEnableClientState(GL_NORMAL_ARRAY);
 
     for (int j = 0; j < N-1; j++) {
 	for (int i = 0; i < N-1; i++) {
 	    GLuint base = j * N + i;
 	    indices[j][i][0] = base;
 	    indices[j][i][1] = base + N;
 	    indices[j][i][2] = base + N + 1;
 	    indices[j][i][3] = base + 1;
 	}
     }
 }
 
 void dump(void)
 {
     unsigned char surface[H][W][3];
 
     glReadPixels(0, 0, H, W, GL_RGB, GL_UNSIGNED_BYTE, surface);
     FILE *fp = fopen("dump.ppm","wb");
     fprintf(fp, "P6\n%d %d\n255\n", W, H);
     fwrite(surface, W * 3, H, fp);
     fclose(fp);
 }
 
 void swap(float m[16], int i, int j)
 {
     float mi = m[i];
     m[i] = m[j];
     m[j] = mi;
 }
 
 void transposeMatrix16(float m[16])
 {
     swap(m, 1, 4);
     swap(m, 2, 8);
     swap(m, 3,12);
     swap(m, 6, 9);
     swap(m, 7,13);
     swap(m,11,14);
 }
 
 const char *error(void)
 {
     GLenum status = glGetError();
 
     switch (status)
     {
     case GL_NO_ERROR:		return NULL;
     case GL_INVALID_ENUM:	return "Invalid Enum";
     case GL_INVALID_VALUE:	return "Invalid Value";
     case GL_INVALID_OPERATION:	return "Invalid Operation";
     case GL_STACK_OVERFLOW:	return "Stack Overflow";
     case GL_STACK_UNDERFLOW:	return "Stack Underflow";
     case GL_OUT_OF_MEMORY:	return "Out of Memory";
     default:			return "Unknown Error";
     }
 }
 
 void check(void)
 {
     for (;;) {
 	const char *msg = error();
 	if (!msg)
 	    break;
 	fputs(msg, stderr);
     }
 }
 
 void init(void)
 {
     glFrontFace(GL_CCW);
     //glEnable(GL_CULL_FACE);
 
     glEnable(GL_DEPTH_TEST);
     glDepthFunc(GL_LEQUAL);
 
     glEnable(GL_LIGHTING);
 
     glMaterialfv(GL_FRONT, GL_EMISSION,  material_emission);
     glMaterialfv(GL_FRONT, GL_AMBIENT,   material_ambient);
     glMaterialfv(GL_FRONT, GL_DIFFUSE,   material_diffuse);
     glMaterialfv(GL_FRONT, GL_SPECULAR,  material_specular);
     glMaterialf( GL_FRONT, GL_SHININESS, material_shininess);
 
     glLightfv(GL_LIGHT0, GL_AMBIENT,  light_ambient);
     glLightfv(GL_LIGHT0, GL_DIFFUSE,  light_diffuse);
     glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
 
     glEnable(GL_LIGHT0);
 
     make_data();
 
     memcpy(lightPos_, light_position, sizeof(lightPos_));
     memcpy(objectPos_, object_position, sizeof(objectPos_));
     memcpy(objectRot_, object_rotation, sizeof(objectRot_));
 
     glGenTextures(1, &shadowmap_);
     glBindTexture(GL_TEXTURE_2D, shadowmap_);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, W, H, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
 
     glGenRenderbuffers(1, &renderbuffer_);
     glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer_);
     glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA, W, H);
 
     glGenFramebuffers(1, &framebuffer_);
     glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_);
     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer_);
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, shadowmap_, 0);
 
     GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
     if (status != GL_FRAMEBUFFER_COMPLETE) {
 	fprintf(stderr, "framebuffer fail\n");
 	exit(1);
     }
 
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
     check();
 }
 
 void renderSceneElements(void)
 {
     glPushMatrix();
 
     glTranslatef(objectPos_[0], objectPos_[1], objectPos_[2]);
     glRotatef(objectRot_[0], 1, 0, 0);
     glRotatef(objectRot_[1], 0, 1, 0);
     glRotatef(objectRot_[2], 0, 0, 1);
 
     glDrawElements(GL_QUADS, (N-1)*(N-1)*4, GL_UNSIGNED_INT, (const GLvoid*) indices);
 
     glPopMatrix();
-    gluLookAt(lightPos_[0], lightPos_[1], lightPos_[2], 0.0, 0.0, -2.0, 0.0, 1.0, 0.0);
+
 
 void draw(void)
 {
     double lightAspect_ = 1.0 * width / height;
 
     // position the light
     glLightfv(GL_LIGHT0, GL_POSITION, lightPos_);
 
     // switch the framebuffer for the first pass
     glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_);
     glViewport(0, 0, W, H);
     glClearColor(0.5, 0.2, 0.1, 1.0f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
 
     // set up the projection parameters from the light's POV
     glMatrixMode(GL_PROJECTION);
     glPushMatrix();
     glLoadIdentity();
     gluPerspective(lightFOV_, lightAspect_, lightNear_, lightFar_);
 
     glMatrixMode(GL_MODELVIEW);
     glPushMatrix();
     glLoadIdentity();
     // translate to the light's position
     gluLookAt(lightPos_[0], lightPos_[1], lightPos_[2],
-    gluLookAt(lightPos_[0], lightPos_[1], lightPos_[2], 0.0, 0.0, -2.0, 0.0, 1.0, 0.0);
+	      objectPos_[0], objectPos_[1], objectPos_[2],
 	      0.0, 1.0, 0.0);
 
     // render the scene to get the depth information
     renderSceneElements();
     glPopMatrix();
 
     // end the projection modification
     glMatrixMode(GL_PROJECTION);
-    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
+
-    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
+
-    glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
+
-    glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
+
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
     glClearColor(1,1,1,1);
-    glTexGenfv(GL_S, GL_OBJECT_PLANE, &planeMatrix[0]);
+
-    glTexGenfv(GL_T, GL_OBJECT_PLANE, &planeMatrix[4]);
+
-    glTexGenfv(GL_R, GL_OBJECT_PLANE, &planeMatrix[8]);
+
-    glTexGenfv(GL_Q, GL_OBJECT_PLANE, &planeMatrix[12]);
+
     float planeMatrix[16];
     glPushMatrix();
     glLoadIdentity();
     // compensate for the eye-coordinate to texture coordinate conversion: [-1,1] to [0,1]
     glTranslatef(0.5f, 0.5f, 0.499f);
     glScalef(0.5f, 0.5f, 0.5f);
 
     // do the perspective projection and translate to the light's position
     gluPerspective(lightFOV_, lightAspect_, lightNear_, lightFar_);
     gluLookAt(lightPos_[0], lightPos_[1], lightPos_[2],
 	      objectPos_[0], objectPos_[1], objectPos_[2],
 	      0.0, 1.0, 0.0);
 
     glGetFloatv(GL_MODELVIEW_MATRIX, planeMatrix);
     glPopMatrix();
 
     // go from OpenGL's column-major to row-major matrix form
     transposeMatrix16(planeMatrix);
 
     glMatrixMode(GL_MODELVIEW);
     glPushMatrix();
     glLoadIdentity();
 
     // set up the type for texture generation
     glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
     glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
     glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
     glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
 
     // data for texture generation
     glTexGenfv(GL_S, GL_EYE_PLANE, &planeMatrix[0]);
     glTexGenfv(GL_T, GL_EYE_PLANE, &planeMatrix[4]);
     glTexGenfv(GL_R, GL_EYE_PLANE, &planeMatrix[8]);
     glTexGenfv(GL_Q, GL_EYE_PLANE, &planeMatrix[12]);
 
     glEnable(GL_TEXTURE_GEN_S);
     glEnable(GL_TEXTURE_GEN_T);
     glEnable(GL_TEXTURE_GEN_R);
     glEnable(GL_TEXTURE_GEN_Q);
 
     glPopMatrix();
 
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    if (k == GLUT_KEY_HOME)
+
-	memcpy(lightPos_, light_position, sizeof(lightPos_));
+
-    key_state[k] = 1;
+
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
     glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
 
     glEnable(GL_TEXTURE_2D);
     glBindTexture(GL_TEXTURE_2D, shadowmap_);
 
     glEnable(GL_LIGHTING);
     glEnable(GL_LIGHT0);
 
     renderSceneElements();
 
     glDisable(GL_LIGHTING);
     glDisable(GL_LIGHT0);
 
     glDisable(GL_TEXTURE_2D);
 
     glDisable(GL_TEXTURE_GEN_Q);
     glDisable(GL_TEXTURE_GEN_R);
     glDisable(GL_TEXTURE_GEN_T);
     glDisable(GL_TEXTURE_GEN_S);
 
     glutSwapBuffers();
-        if (!key_state[k])
+
 
-        if (k == GLUT_KEY_LEFT)      lightPos_[0] -= move * t;
+
-        if (k == GLUT_KEY_RIGHT)     lightPos_[0] += move * t;
+
-        if (k == GLUT_KEY_DOWN)      lightPos_[1] -= move * t;
+
-        if (k == GLUT_KEY_UP)        lightPos_[1] += move * t;
+
-        if (k == GLUT_KEY_PAGE_DOWN) lightPos_[2] -= move * t;
+
-        if (k == GLUT_KEY_PAGE_UP)   lightPos_[2] += move * t;
+
 void special(int k, int x, int y)
 {
     int mod = glutGetModifiers();
     int ctrl = mod & GLUT_ACTIVE_CTRL;
     int shift = mod & GLUT_ACTIVE_SHIFT;
 
     if (k == GLUT_KEY_HOME) {
 	if (ctrl)
 	    memcpy(lightPos_, light_position, sizeof(lightPos_));
 	else if (shift)
 	    memcpy(objectRot_, object_rotation, sizeof(objectRot_));
 	else
 	    memcpy(objectPos_, object_position, sizeof(objectPos_));
     }
 
     if (ctrl)
 	key_state[k] = CTRL;
     else if (shift)
 	key_state[k] = SHIFT;
     else
 	key_state[k] = DOWN;
 
     glutPostRedisplay();
 }
 
 void special_up(int k, int x, int y)
 {
     key_state[k] = 0;
     glutPostRedisplay();
 }
 
 void idle(void)
 {
     struct timeval tv;
     gettimeofday(&tv, NULL);
     double now = tv.tv_sec + tv.tv_usec * 1.0e-6;
 
     if (last <= 0)
         last = now;
     double t = now - last;
     last = now;
 
     double move = 1.0;
     double rot = 45.0;
 
     for (int k = 0; k < 0x100; k++) {
 	int s = key_state[k];
         if (!s)
             continue;
 	if (s == CTRL) {
 	    if (k == GLUT_KEY_LEFT)      lightPos_[0] -= move * t;
 	    if (k == GLUT_KEY_RIGHT)     lightPos_[0] += move * t;
 	    if (k == GLUT_KEY_DOWN)      lightPos_[1] -= move * t;
 	    if (k == GLUT_KEY_UP)        lightPos_[1] += move * t;
 	    if (k == GLUT_KEY_PAGE_DOWN) lightPos_[2] -= move * t;
 	    if (k == GLUT_KEY_PAGE_UP)   lightPos_[2] += move * t;
 	}
 	if (s == SHIFT) {
 	    if (k == GLUT_KEY_DOWN)      objectRot_[0] -= rot * t;
 	    if (k == GLUT_KEY_UP)        objectRot_[0] += rot * t;
 	    if (k == GLUT_KEY_RIGHT)     objectRot_[1] -= rot * t;
 	    if (k == GLUT_KEY_LEFT)      objectRot_[1] += rot * t;
 	    if (k == GLUT_KEY_PAGE_DOWN) objectRot_[2] -= rot * t;
 	    if (k == GLUT_KEY_PAGE_UP)   objectRot_[2] += rot * t;
 	}
 	if (s == DOWN) {
 	    if (k == GLUT_KEY_LEFT)      objectPos_[0] -= move * t;
 	    if (k == GLUT_KEY_RIGHT)     objectPos_[0] += move * t;
 	    if (k == GLUT_KEY_DOWN)      objectPos_[1] -= move * t;
 	    if (k == GLUT_KEY_UP)        objectPos_[1] += move * t;
 	    if (k == GLUT_KEY_PAGE_DOWN) objectPos_[2] -= move * t;
 	    if (k == GLUT_KEY_PAGE_UP)   objectPos_[2] += move * t;
 	}
     }
 
     glutPostRedisplay();
 }
 
 void resize(int w, int h)
 {
     if (h == 0)
         h = 1;
 
     width = w;
     height = h;
 
     glViewport(0, 0, w, h);
     glPushAttrib(GL_TRANSFORM_BIT);
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
     gluPerspective(lightFOV_, 1.0 * w / h, lightNear_, lightFar_);
     glPopAttrib();
 }
 
 int main(int argc, char **argv)
 {
     glutInit(&argc, argv);
 
     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
     glutInitWindowSize(W, H);
 
     glutCreateWindow("Shadow map");
 
     glutDisplayFunc(draw);
     glutReshapeFunc(resize);
     glutKeyboardFunc(key);
     glutSpecialFunc(special);
     glutSpecialUpFunc(special_up);
     glutIdleFunc(idle);
 
     init();
 
     glutMainLoop();
 
     return 0;
 }