خاص لمبرمجي الopenGL أرجوا المساعدة بأسرع وقت ممكن

الرجاء من مبرمجي ال openGLمساعدتي في فهم هذا البرنامج بأسرع وقت ممكن لأنو بصراحة فيه أشياء كثيرة مهي واضحة فيه فياريت الي عندو معلومة عن الدوال الموجودة فيه يشرحلي هيا بلييييز ومشكورين والله يعطيكم ألف ألف ألف عافية

والشكل الناتج لهذا البنامج هو

عبارة عن شعار الolympic

[CODE]#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <GL/glut.h>

/* Some <math.h> files do not define M_PI... */
#ifndef M_PI
#define M_PI 3.141592654
#endif

#ifdef WIN32
#define drand48() (((float) rand())/((float) RAND_MAX))
#define srand48(x) (srand((x)))
#else
extern double drand48(void);
extern void srand48(long seedval);
#endif

#define XSIZE   100
#define YSIZE   75

#define RINGS 5
#define BLUERING 0
#define BLACKRING 1
#define REDRING 2
#define YELLOWRING 3
#define GREENRING 4

#define BACKGROUND 8

enum {
  BLACK = 0,
  RED,
  GREEN,
  YELLOW,
  BLUE,
  MAGENTA,
  CYAN,
  WHITE
};

typedef short Point[2];

GLenum rgb, doubleBuffer, directRender;

unsigned char rgb_colors[RINGS][3];
int mapped_colors[RINGS];
float dests[RINGS][3];
float offsets[RINGS][3];
float angs[RINGS];
float rotAxis[RINGS][3];
int iters[RINGS];
GLuint theTorus;

void
FillTorus(float rc, int numc, float rt, int numt)
{
  int i, j, k;
  double s, t;
  double x, y, z;
  double pi, twopi;

  pi = M_PI;
  twopi = 2 * pi;

  for (i = 0; i < numc; i++) {
    glBegin(GL_QUAD_STRIP);
    for (j = 0; j <= numt; j++) {
      for (k = 1; k >= 0; k--) {
        s = (i + k) % numc + 0.5;
        t = j % numt;

        x = cos(t * twopi / numt) * cos(s * twopi / numc);
        y = sin(t * twopi / numt) * cos(s * twopi / numc);
        z = sin(s * twopi / numc);
        glNormal3f(x, y, z);

        x = (rt + rc * cos(s * twopi / numc)) * cos(t * twopi / numt);
        y = (rt + rc * cos(s * twopi / numc)) * sin(t * twopi / numt);
        z = rc * sin(s * twopi / numc);
        glVertex3f(x, y, z);
      }
    }
    glEnd();
  }
}

float
Clamp(int iters_left, float t)
{

  if (iters_left < 3) {
    return 0.0;
  }
  return (iters_left - 2) * t / iters_left;
}

void
Idle(void)
{
  int i, j;
  int more = GL_FALSE;

  for (i = 0; i < RINGS; i++) {
    if (iters) {
      for (j = 0; j < 3; j++) {
        offsets[j] = Clamp(iters, offsets[j]);
      }
      angs = Clamp(iters, angs);
      iters--;
      more = GL_TRUE;
    }
  }
  if (more) {
    glutPostRedisplay();
  } else {
    glutIdleFunc(NULL);
  }
}

void
DrawScene(void)
{
  int i;

  glPushMatrix();

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  gluLookAt(0, 0, 10, 0, 0, 0, 0, 1, 0);

  for (i = 0; i < RINGS; i++) {
    if (rgb) {
      glColor3ubv(rgb_colors);
    } else {
      glIndexi(mapped_colors);
    }
    glPushMatrix();
    glTranslatef(dests[0] + offsets[0], dests[1] + offsets[1],
      dests[2] + offsets[2]);
    glRotatef(angs, rotAxis[0], rotAxis[1], rotAxis[2]);
    glCallList(theTorus);
    glPopMatrix();
  }

  glPopMatrix();
  if (doubleBuffer) {
    glutSwapBuffers();
  } else {
    glFlush();
  }
}

float
MyRand(void)
{
  return 10.0 * (drand48() - 0.5);
}

void
ReInit(void)
{
  int i;
  float deviation;

  deviation = MyRand() / 2;
  deviation = deviation * deviation;
  for (i = 0; i < RINGS; i++) {
    offsets[0] = MyRand();
    offsets[1] = MyRand();
    offsets[2] = MyRand();
    angs = 260.0 * MyRand();
    rotAxis[0] = MyRand();
    rotAxis[1] = MyRand();
    rotAxis[2] = MyRand();
    iters = (deviation * MyRand() + 60.0);
  }
}

void
Init(void)
{
  int i;
  float top_y = 1.0;
  float bottom_y = 0.0;
  float top_z = 0.15;
  float bottom_z = 0.69;
  float spacing = 2.5;
  static float lmodel_ambient[] =
  {0.0, 0.0, 0.0, 0.0};
  static float lmodel_twoside[] =
  {GL_FALSE};
  static float lmodel_local[] =
  {GL_FALSE};
  static float light0_ambient[] =
  {0.1, 0.1, 0.1, 1.0};
  static float light0_diffuse[] =
  {1.0, 1.0, 1.0, 0.0};
  static float light0_position[] =
  {0.8660254, 0.5, 1, 0};
  static float light0_specular[] =
  {1.0, 1.0, 1.0, 0.0};
  static float bevel_mat_ambient[] =
  {0.0, 0.0, 0.0, 1.0};
  static float bevel_mat_shininess[] =
  {40.0};
  static float bevel_mat_specular[] =
  {1.0, 1.0, 1.0, 0.0};
  static float bevel_mat_diffuse[] =
  {1.0, 0.0, 0.0, 0.0};

  srand48(0x102342);
  ReInit();
  for (i = 0; i < RINGS; i++) {
    rgb_colors[0] = rgb_colors[1] = rgb_colors[2] = 0;
  }
  rgb_colors[BLUERING][2] = 255;
  rgb_colors[REDRING][0] = 255;
  rgb_colors[GREENRING][1] = 255;
  rgb_colors[YELLOWRING][0] = 255;
  rgb_colors[YELLOWRING][1] = 255;
  mapped_colors[BLUERING] = BLUE;
  mapped_colors[REDRING] = RED;
  mapped_colors[GREENRING] = GREEN;
  mapped_colors[YELLOWRING] = YELLOW;
  mapped_colors[BLACKRING] = BLACK;

  dests[BLUERING][0] = -spacing;
  dests[BLUERING][1] = top_y;
  dests[BLUERING][2] = top_z;

  dests[BLACKRING][0] = 0.0;
  dests[BLACKRING][1] = top_y;
  dests[BLACKRING][2] = top_z;

  dests[REDRING][0] = spacing;
  dests[REDRING][1] = top_y;
  dests[REDRING][2] = top_z;

  dests[YELLOWRING][0] = -spacing / 2.0;
  dests[YELLOWRING][1] = bottom_y;
  dests[YELLOWRING][2] = bottom_z;

  dests[GREENRING][0] = spacing / 2.0;
  dests[GREENRING][1] = bottom_y;
  dests[GREENRING][2] = bottom_z;

  theTorus = glGenLists(1);
  glNewList(theTorus, GL_COMPILE);
  FillTorus(0.1, 8, 1.0, 25);
  glEndList();

  glEnable(GL_CULL_FACE);
  glCullFace(GL_BACK);
  glEnable(GL_DEPTH_TEST);
  glClearDepth(1.0);

  if (rgb) {
    glClearColor(0.5, 0.5, 0.5, 0.0);
    glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light0_specular);
    glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
    glEnable(GL_LIGHT0);

    glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, lmodel_local);
    glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
    glEnable(GL_LIGHTING);

    glMaterialfv(GL_FRONT, GL_AMBIENT, bevel_mat_ambient);
    glMaterialfv(GL_FRONT, GL_SHININESS, bevel_mat_shininess);
    glMaterialfv(GL_FRONT, GL_SPECULAR, bevel_mat_specular);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, bevel_mat_diffuse);

    glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
    glEnable(GL_COLOR_MATERIAL);
    glShadeModel(GL_SMOOTH);
  } else {
    glClearIndex(BACKGROUND);
    glShadeModel(GL_FLAT);
  }

  glMatrixMode(GL_PROJECTION);
  gluPerspective(45, 1.33, 0.1, 100.0);
  glMatrixMode(GL_MODELVIEW);
}

void
Reshape(int width, int height)
{
  glViewport(0, 0, width, height);
}

/* ARGSUSED1 */
void
Key(unsigned char key, int x, int y)
{

  switch (key) {
  case 27:
    exit(0);
    break;
  case ' ':
    ReInit();
    glutIdleFunc(Idle);
    break;
  }
}

GLenum
Args(int argc, char **argv)
{
  GLint i;

  rgb = GL_TRUE;
  doubleBuffer = GL_TRUE;

  for (i = 1; i < argc; i++) {
    if (strcmp(argv, "-ci") == 0) {
      rgb = GL_FALSE;
    } else if (strcmp(argv, "-rgb") == 0) {
      rgb = GL_TRUE;
    } else if (strcmp(argv, "-sb") == 0) {
      doubleBuffer = GL_FALSE;
    } else if (strcmp(argv, "-db") == 0) {
      doubleBuffer = GL_TRUE;
    } else {
      printf("%s (Bad option).\n", argv);
      return GL_FALSE;
    }
  }
  return GL_TRUE;
}

void
visible(int vis)
{
  if (vis == GLUT_VISIBLE) {
    glutIdleFunc(Idle);
  } else {
    glutIdleFunc(NULL);
  }
}

int
main(int argc, char **argv)
{
  GLenum type;

  glutInitWindowSize(400, 300);
  glutInit(&argc, argv);
  if (Args(argc, argv) == GL_FALSE) {
    exit(1);
  }
  type = (rgb) ? GLUT_RGB : GLUT_INDEX;
  type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE;
  glutInitDisplayMode(type);

  glutCreateWindow("Olympic");

  Init();

  glutReshapeFunc(Reshape);
  glutKeyboardFunc(Key);
  glutDisplayFunc(DrawScene);

  glutVisibilityFunc(visible);

  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */