2021年5月3日 星期一

𝔍𝔒𝔗𝔇-week11

 

電腦圖學_week11

2021/05/03(一)

       今日的上課內容:
  1. 改檔名為libglut32.a
  2. 下載檔案
  3. 放入檔案
  4. 打開專案看到結果
  5. 重寫30行看到未打光的模型
    今日程式碼:
///複製transformation.c的
  • /*
  •     transformation.c
  •     Nate Robins, 1997

  •     Tool for teaching about OpenGL transformations.

  •  */


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



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


  • cell translation[3] = {
  •     { 1, 120, 40, -5.0, 5.0, 0.0, 0.01,
  •       "Specifies X coordinate of translation vector.", "%.2f" },
  •     { 2, 180, 40, -5.0, 5.0, 0.0, 0.01,
  •       "Specifies Y coordinate of translation vector.", "%.2f" },
  •     { 3, 240, 40, -5.0, 5.0, 0.0, 0.01,
  •       "Specifies Z coordinate of translation vector.", "%.2f" },
  • };

  • cell rotation[4] = {
  •     { 4, 120, 80, -360.0, 360.0, 0.0, 1.0,
  •       "Specifies angle of rotation, in degrees.", "%.1f" },
  •     { 5, 180, 80, -1.0, 1.0, 0.0, 0.01,
  •       "Specifies X coordinate of vector to rotate about.", "%.2f" },
  •     { 6, 240, 80, -1.0, 1.0, 1.0, 0.01,
  •       "Specifies Y coordinate of vector to rotate about.", "%.2f" },
  •     { 7, 300, 80, -1.0, 1.0, 0.0, 0.01,
  •       "Specifies Z coordinate of vector to rotate about.", "%.2f" },
  • };

  • cell scale[3] = {
  •     {  8, 120, 120, -5.0, 5.0, 1.0, 0.01,
  •        "Specifies scale factor along X axis.", "%.2f" },
  •     {  9, 180, 120, -5.0, 5.0, 1.0, 0.01,
  •        "Specifies scale factor along Y axis.", "%.2f" },
  •     { 10, 240, 120, -5.0, 5.0, 1.0, 0.01,
  •        "Specifies scale factor along Z axis.", "%.2f" },
  • };

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

  • GLboolean swapped = GL_FALSE;
  • GLboolean world_draw = GL_TRUE;
  • GLMmodel* pmodel = NULL;
  • GLint selection = 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, 240, cell->info);
  • glColor3ub(255, 0, 0);
  •     }

  •     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-30 && 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/porsche.obj");
  • if (!pmodel) exit(0);
  • glmUnitize(pmodel);
  • glmFacetNormals(pmodel);
  • glmVertexNormals(pmodel, 90.0);
  •     }

  •     glmDraw(pmodel, GLM_SMOOTH | GLM_MATERIAL);
  • }

  • 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)/2.0;
  •     sub_height = (height-GAP*3)/2.0;

  •     glutSetWindow(world);
  •     glutPositionWindow(GAP, GAP);
  •     glutReshapeWindow(sub_width, sub_height);
  •     glutSetWindow(screen);
  •     glutPositionWindow(GAP+sub_width+GAP, GAP);
  •     glutReshapeWindow(sub_width, sub_height);
  •     glutSetWindow(command);
  •     glutPositionWindow(GAP, GAP+sub_height+GAP);
  •     glutReshapeWindow(sub_width+GAP+sub_width, sub_height);
  • }

  • 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, "World-space view");
  •     drawstr(GAP+sub_width+GAP, GAP-5, "Screen-space view");
  •     drawstr(GAP, GAP+sub_height+GAP-5, "Command manipulation window");
  •     glutSwapBuffers();
  • }

  • void
  • main_keyboard(unsigned char key, int x, int y)
  • {
  •     switch (key) {
  •     case 's':
  •         swapped = !swapped;
  •         break;
  •     case 'r':
  • translation[0].value = 0.0;
  • translation[1].value = 0.0;
  • translation[2].value = 0.0;
  • rotation[0].value = 0.0;
  • rotation[1].value = 0.0;
  • rotation[2].value = 1.0;
  • rotation[3].value = 0.0;
  • scale[0].value = 1.0;
  • scale[1].value = 1.0;
  • scale[2].value = 1.0;
  • break;
  •     case 27:
  • exit(0);
  •     }

  •     redisplay_all();
  • }

  • 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, -5.0);
  •     glRotatef(-45.0, 0.0, 1.0, 0.0);
  •     glClearColor(0.0, 0.0, 0.0, 0.0);
  •     glEnable(GL_DEPTH_TEST);
  •     glEnable(GL_LIGHT0);
  • }

  • void
  • world_display(void)
  • {
  •     GLfloat pos[] = { 0.0, 0.0, 1.0, 0.0 };
  •     double length;
  •     float l[3];

  •     l[0] = at[0] - eye[0];
  •     l[1] = at[0] - eye[1];
  •     l[2] = at[0] - eye[2];
  •     length = normalize(l);

  •     invert(modelview, inverse);

  •     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  •     if (world_draw) {
  • glEnable(GL_LIGHTING);
  • glPushMatrix();
  • glMultMatrixd(inverse);
  • glLightfv(GL_LIGHT0, GL_POSITION, pos);
  • glPopMatrix();
  • drawmodel();
  • glDisable(GL_LIGHTING);
  •     }

  •     glPushMatrix();

  •     glMultMatrixd(inverse);

  •     glLightfv(GL_LIGHT0, GL_POSITION, pos);

  •     /* 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
  • world_menu(int value)
  • {
  •     switch (value) {
  •     case 'm':
  • world_draw = !world_draw;
  • 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]);
  •     if (swapped) {
  •       glRotatef(rotation[0].value, rotation[1].value,
  • rotation[2].value, rotation[3].value);
  •       glTranslatef(translation[0].value, translation[1].value,
  •    translation[2].value);
  •     } else {
  •       glTranslatef(translation[0].value, translation[1].value,
  •    translation[2].value);
  •       glRotatef(rotation[0].value, rotation[1].value,
  • rotation[2].value, rotation[3].value);
  •     }
  •     glScalef(scale[0].value, scale[1].value, scale[2].value);
  •     glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
  •     glClearColor(0.2, 0.2, 0.2, 0.0);
  •     glEnable(GL_DEPTH_TEST);
  •     glEnable(GL_LIGHTING);
  •     glEnable(GL_LIGHT0);
  • }

  • void
  • screen_display(void)
  • {
  •     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  •     drawmodel();
  •     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;
  •     }

  •     if (name) {
  • pmodel = glmReadOBJ(name);
  • if (!pmodel) exit(0);
  • glmUnitize(pmodel);
  • glmFacetNormals(pmodel);
  • glmVertexNormals(pmodel, 90.0);
  •     }

  •     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
  • command_display(void)
  • {
  •     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  •     if (swapped) {
  • translation[0].y = 80;
  • translation[1].y = 80;
  • translation[2].y = 80;
  • rotation[0].y = 40;
  • rotation[1].y = 40;
  • rotation[2].y = 40;
  • rotation[3].y = 40;
  •     } else {
  • translation[0].y = 40;
  • translation[1].y = 40;
  • translation[2].y = 40;
  • rotation[0].y = 80;
  • rotation[1].y = 80;
  • rotation[2].y = 80;
  • rotation[3].y = 80;
  •     }

  •     glColor3ub(255, 255, 255);
  •     setfont("helvetica", 18);
  •     drawstr(30, rotation[0].y, "glRotatef(");
  •     drawstr(170, rotation[0].y, ",");
  •     drawstr(230, rotation[0].y, ",");
  •     drawstr(290, rotation[0].y, ",");
  •     drawstr(350, rotation[0].y, ");");
  •     drawstr(10, translation[0].y, "glTranslatef(");
  •     drawstr(170, translation[0].y, ",");
  •     drawstr(230, translation[0].y, ",");
  •     drawstr(290, translation[0].y, ");");
  •     drawstr(38, 120, "glScalef(");
  •     drawstr(170, 120, ",");
  •     drawstr(230, 120, ",");
  •     drawstr(290, 120, ");");
  •     drawstr(41, 160, "glBegin(  . . .  );");
  •     drawstr(41, 200, " . . .");

  •     cell_draw(&translation[0]);
  •     cell_draw(&translation[1]);
  •     cell_draw(&translation[2]);

  •     cell_draw(&rotation[0]);
  •     cell_draw(&rotation[1]);
  •     cell_draw(&rotation[2]);
  •     cell_draw(&rotation[3]);

  •     cell_draw(&scale[0]);
  •     cell_draw(&scale[1]);
  •     cell_draw(&scale[2]);

  •     if (!selection) {
  • glColor3ub(255, 255, 0);
  • drawstr(10, 240,
  •      "Click on the arguments and move the mouse to modify values.");
  •     }

  •     glutSwapBuffers();
  • }

  • int old_y;

  • void
  • command_mouse(int button, int state, int x, int y)
  • {
  •     selection = 0;

  •     if (state == GLUT_DOWN) {
  • /* mouse should only hit _one_ of the cells, so adding up all
  •            the hits just propagates a single hit. */
  • selection += cell_hit(&translation[0], x, y);
  • selection += cell_hit(&translation[1], x, y);
  • selection += cell_hit(&translation[2], x, y);
  • selection += cell_hit(&rotation[0], x, y);
  • selection += cell_hit(&rotation[1], x, y);
  • selection += cell_hit(&rotation[2], x, y);
  • selection += cell_hit(&rotation[3], x, y);
  • selection += cell_hit(&scale[0], x, y);
  • selection += cell_hit(&scale[1], x, y);
  • selection += cell_hit(&scale[2], x, y);
  •     }

  •     old_y = y;

  •     redisplay_all();
  • }

  • void
  • command_motion(int x, int y)
  • {
  •     cell_update(&translation[0], old_y-y);
  •     cell_update(&translation[1], old_y-y);
  •     cell_update(&translation[2], old_y-y);
  •     cell_update(&rotation[0], old_y-y);
  •     cell_update(&rotation[1], old_y-y);
  •     cell_update(&rotation[2], old_y-y);
  •     cell_update(&rotation[3], old_y-y);
  •     cell_update(&scale[0], old_y-y);
  •     cell_update(&scale[1], old_y-y);
  •     cell_update(&scale[2], old_y-y);

  •     old_y = y;

  •     redisplay_all();
  • }

  • void
  • command_menu(int value)
  • {
  •     main_keyboard((unsigned char)value, 0, 0);
  • }

  • void
  • redisplay_all(void)
  • {
  •     glutSetWindow(command);
  •     glutPostRedisplay();
  •     glutSetWindow(world);
  •     world_reshape(sub_width, sub_height);
  •     glutPostRedisplay();
  •     glutSetWindow(screen);
  •     screen_reshape(sub_width, sub_height);
  •     glutPostRedisplay();
  • }

  • int
  • main(int argc, char** argv)
  • {
  •     glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
  •     glutInitWindowSize(512+GAP*3, 512+GAP*3);
  •     glutInitWindowPosition(50, 50);
  •     glutInit(&argc, argv);

  •     window = glutCreateWindow("week11_model");
  •     glutReshapeFunc(main_reshape);
  •     glutDisplayFunc(main_display);
  •     glutKeyboardFunc(main_keyboard);

  •     world = glutCreateSubWindow(window, GAP, GAP, 256, 256);
  •     glutReshapeFunc(world_reshape);
  •     glutDisplayFunc(world_display);
  •     glutKeyboardFunc(main_keyboard);
  •     glutCreateMenu(world_menu);
  •     glutAddMenuEntry("Toggle model", 'm');
  •     glutAttachMenu(GLUT_RIGHT_BUTTON);

  •     screen = glutCreateSubWindow(window, GAP+256+GAP, GAP, 256, 256);
  •     glutReshapeFunc(screen_reshape);
  •     glutDisplayFunc(screen_display);
  •     glutKeyboardFunc(main_keyboard);
  •     glutCreateMenu(screen_menu);
  •     glutAddMenuEntry("Models", 0);
  •     glutAddMenuEntry("", 0);
  •     glutAddMenuEntry("Soccerball", 's');
  •     glutAddMenuEntry("Al Capone", 'a');
  •     glutAddMenuEntry("F-16 Jet", 'j');
  •     glutAddMenuEntry("Dolphins", 'd');
  •     glutAddMenuEntry("Flowers", 'f');
  •     glutAddMenuEntry("Porsche", 'p');
  •     glutAddMenuEntry("Rose", 'r');
  •     glutAttachMenu(GLUT_RIGHT_BUTTON);

  •     command = glutCreateSubWindow(window, GAP+256+GAP, GAP+256+GAP, 256, 256);
  •     glutReshapeFunc(command_reshape);
  •     glutDisplayFunc(command_display);
  •     glutMotionFunc(command_motion);
  •     glutMouseFunc(command_mouse);
  •     glutKeyboardFunc(main_keyboard);
  •     glutCreateMenu(command_menu);
  •     glutAddMenuEntry("Projection", 0);
  •     glutAddMenuEntry("", 0);
  •     glutAddMenuEntry("[s]  Swap translate/rotate", 's');
  •     glutAddMenuEntry("[r]  Reset parameters", 'r');
  •     glutAddMenuEntry("", 0);
  •     glutAddMenuEntry("Quit", 27);
  •     glutAttachMenu(GLUT_RIGHT_BUTTON);

  •     redisplay_all();

  •     glutMainLoop();

  •     return 0;
  • }
///未打光的模型
  • #include "glm.h"
  • GLMmodel* pmodel = NULL;

  • void drawmodel(void)
  • {///使用範例的程式
  •     if(!pmodel)
  •     {
  •         pmodel = glmReadOBJ("data/f-16.obj");
  •         if(!pmodel) exit(0);
  •         glmUnitize(pmodel);
  •         glmFacetNormals(pmodel);
  •         glmVertexNormals(pmodel, 90.0);
  •     }

  •     glmDraw(pmodel, GLM_SMOOTH | GLM_MATERIAL);
  • }
  • void display()
  • {
  •     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  •     drawmodel();///使用範例的程式
  •     glutSwapBuffers();
  • }
  • int main(int argc, char**argv)
  • {
  •     glutInit(&argc, argv);
  •     glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH);
  •     glutCreateWindow("week11");

  •     glutDisplayFunc(display);
  •     glutMainLoop();
  • }
////有打光轉向的模型
#include "glm.h"
GLMmodel* pmodel = NULL;

void drawmodel(void)
{///使用範例的程式
    if(!pmodel)
    {
        pmodel = glmReadOBJ("data/al.obj");
        if(!pmodel) exit(0);
        glmUnitize(pmodel);
        glmFacetNormals(pmodel);
        glmVertexNormals(pmodel, 90.0);
    }

    glmDraw(pmodel, GLM_SMOOTH | GLM_MATERIAL);
}
void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glPushMatrix();
        glRotatef(180, 0,1,0);
        drawmodel();///使用範例的程式
    glPopMatrix();
    glutSwapBuffers();
}
///打光的陣列
  • const GLfloat light_ambient[]  = { 0.0f, 0.0f, 0.0f, 1.0f };
  • const GLfloat light_diffuse[]  = { 1.0f, 1.0f, 1.0f, 1.0f };
  • const GLfloat light_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
  • const GLfloat light_position[] = { 2.0f, 5.0f, -5.0f, 0.0f };

  • const GLfloat mat_ambient[]    = { 0.7f, 0.7f, 0.7f, 1.0f };
  • const GLfloat mat_diffuse[]    = { 0.8f, 0.8f, 0.8f, 1.0f };
  • const GLfloat mat_specular[]   = { 1.0f, 1.0f, 1.0f, 1.0f };
  • const GLfloat high_shininess[] = { 100.0f };


  • int main(int argc, char**argv)
  • {
  •     glutInit(&argc, argv);
  •     glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH);
  •     glutCreateWindow("week11");
  •     ///打光的設定
  •     glEnable(GL_DEPTH_TEST);
  •     glDepthFunc(GL_LESS);
  •     glEnable(GL_LIGHT0);
  •     glEnable(GL_NORMALIZE);
  •     glEnable(GL_COLOR_MATERIAL);
  •     glEnable(GL_LIGHTING);

  •     glLightfv(GL_LIGHT0, GL_AMBIENT,  light_ambient);
  •     glLightfv(GL_LIGHT0, GL_DIFFUSE,  light_diffuse);
  •     glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
  •     glLightfv(GL_LIGHT0, GL_POSITION, light_position);

  •     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);
  •     glutDisplayFunc(display);
  •     glutMainLoop();
  • }

    今日成果:







於
標籤： ,

沒有留言:

張貼留言

訂閱： 張貼留言 (Atom)

Week18期末作業(橘貓的跳舞熊熊)

 期末作業(橘貓的跳舞熊熊) 影片: https://youtu.be/R89tptMaQZw 程式碼: #include <opencv/highgui.h> #include <opencv/cv.h> #include <GL/glut.h...

  • JOJO的電腦圖學_week08
     210412 week08 🔔❤️ 首先先來下載個openCV 記得這個步驟是選擇中間那一項 其他都是預設值即可 下載好長醬 開啟codeblocks＞Setting compiler... 打開長醬 點Search directories＞Compiler Add一個  C...
  • 哇珍妮佛羅培茲week06
     先去github抓上禮拜的畫畫程式碼 改成 他會變成你滑鼠靠近就會傾斜的樣子。 但我們可以再更簡化，並把藍色一條改成白色的方塊~ 大概會像這樣，依然可以用滑鼠旋轉他。 之後我想讓他變成長方形然後旋轉 只需要改兩三個地方(註解付在圖上了) 現在我要讓他多一隻手然後像關節那樣所以我...
  • JOJO的電腦圖學_week17
      210614 week17                                                                                                                             ...