ÈÓÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜã Çááå ÇáÑøðÍãä ÇáÑøðÍíÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜã
Óíßæä ÇáÏÑÓ Åä ÔÇÁ Çááå Íæá ÇáÖáÇá æ ÇáÅäÚßÇÓÇÊ ÈÅÓÊÚãÇá ÐÇßÑÉ ÇáÅÓÊäÓá
æäÇÊÌ ÇáÏÑÓ Óíßæä ÈåÐÇ ÇáÔßá, åæÚÈÇÑÉ Úä ÕäÏæÞ æ ÕÝíÍÉ
ÃÔÈå ÈÎÔÈÉ ãáãÚÉ, ããÇ ÊÎáÞ ÅäÚßÇÓ æ Öá

áäÈÏÁ ÈÇáÅäÚßÇÓ Ýåæ ÃÞá Óåæáå Úä ÞÈíáå ÇáÖá, ÇáßÇÆäÇÊ ÇáÊí ÊÙåÑ Ýí ÇáãÓØÍ áíÓÊ Óæì äÝÓ ÇáßÇÆäÇÊ ÇáãÑÓæãÉ Ýí ÍÞíÞÉ ÇáÚÇáã ÇáËáÇËí ÇáÃÈÚÇÏ, æÞÏ Êã ÅÖÇÝÉ Þáíá ãä ÇáÔÝÇÝíÉ Ýí ÇáãÓØÍ ÈÃÚáì ÇáÔßá, ÊÎíá Ãäå áæ áã ÊÖÇÝ ÇáÔÝÇÝíÉ áßÇä ÇáÓØÍ ÇáÚÇßÓ ÃÔÈÉ ÈÇáãÑÇÉ æ ÍíäåÇ áíÓ ãä ÇáÊÚÞá ÅÖÇÝÉ ÇáÖáÇá .
áæ ÞáÊ áß Ãääí ÓÃÑÓã ÇáÔßá Ëã ÃÚíÏ ÑÓãå ËÇäíÉ ÈÇáÔßá ÇáãÞáæÈ, ÓÊÞæá áí ÃäåÇ ÝßÑÉ ÚÇÏíÉ æáßäåÇ ÇáÍÞíÞÉ , æÓÊÞæá áí Ãä ÇáÈÑäÇãÌ Óíßæä ãËÞáÇ , áÐÇ æ áåÐÇ ÇáÓÈÈ ÃæÌÏ ÇáÎÈÑÇÁ æÓíáÉ áÊÓÑíÚ ÚãíáÉ ÇáÅäÚßÇÓ æ ÇáÊÖáíá ÝßÇäÊ ÐÇßÑÉ ÇáÅÓÊäÓá.
Ýí ÇáÍÞíÞÉ , áã ÊÎáÞ ãßÊÈÇÊ OpenGL ÏæÇá áÅäÔÇÁ ÇáÖá æ ÇáÅäÚßÇÓ ãËáÇ:glShaddow Ãæ glReflection
Èá åäÇß ØÑíÞÉ ÊãÑ ÈÚÏÉ ãÑÇÍá íÊã ÝíåÇ ÅäÔÇÁ ÊÃËíÑÇÊ ÇáÖáÇá æ ÇáÅäÚßÇÓ .
íÑÌì ÇáÊÞíÏ ÈÇáãÑÇÍá Ýåí ÍÓÇÓÉ áÍÇáÉ ÍÏæË ÇáÃÎØÇÁ:
1 : ÍÝÙ ÇáãÕÝæÝÉ ÇáÊí ÓÊÃÎÐ ÈíÇäÇÊ ÇáÔßá ÇáãÚßæÓ Ýí ÇáãßÏÓ stack æåÐÇ ÈÅÓÊÎÏÇã ÇáÏÇáÉ glPushMatrix
2 : ÈÅÓÊÚãÇá ÏÇáÉ glScalef äÊãßä ãä ÞáÈ ÇáÔßá ÑÃÓÇ Úáì ÚÞÈ ãËáÇ: (glScalef(1.0, -1.0, 1.0 åÐÇíÓãÍ ÈÞáÈ ÇáãÌÓãÇÊ Úáì ÇáãÍæÑ Ú ÇáÊí ÓÊãËá ÇáãÌÓãÇÊ ÇáãÚßæÓÉ.
3 :ÅÚÏÇÏ ãÕÇÏÑ ãæÇÞÚ ÇáÖæÁ, Ýåí ÃíÙÇ ÊÚßÓ.
4 :ÑÓã ÇáßÇÆä æåæ ÈÇáÐÇÊ ÇáßÇÆä ÇáÐí ÓíäÚßÓ.
5 :ÅÎÑÇÌ ÇáãÕÝæÝÉ ÇáÊí ÃÎÐÊ ÈíÇäÇÊ ÇáßÇÆä ÇáãÚßæÓ ãä ÇáãßÏÓ ÈÅÓÊÎÏÇã glPopMatrix
6 : ÅÚÏÇÏ ÇáãÕÏÑ ÇáÃÕáí áãæÇÞÚ ÇáÖæÁ.
7 :ÃÎíÑÇ ÑÓã ÇáãÌÓã ÇáÐí ÓíãËá ÇáÌÓã ÇáÚÇßÓ æÝí ÇáãËÇá ÃÚáÇå íãËá ÈãÓÊØíá (ÇáÎÔÈÉ ÇáãáãÚÉ).

glPushMatrix();
     gluLookAt (CUBE_R*NB_CUBE_X/2, 22, 30 ,CUBE_R*NB_CUBE_X/2, 21.9, 29 0, 1, 0);
     float zz=float(2*CUBE_R * (3 + 2*sin(tt/3000)));
     glPushMatrix();
         glScalef(1.0, -1.0, 1.0);
         for (int x = 0 ; x < NB_CUBE_X ; x++)
              for (int y = 0 ; y < NB_CUBE_Y ; y++) 
                   for (int z = 0 ; z < NB_CUBE_Z ; z++)
                   {
                         Cube[x][y][z]->Update(t);
                         Cube[x][y][z]->Draw(0,-20,zz+20);
                    }
     glPopMatrix();
     glDisable(GL_LIGHTING);
     glDisable(GL_TEXTURE_2D);
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        drawFloor();
     glDisable(GL_BLEND);
     glEnable(GL_TEXTURE_2D);
     glEnable(GL_LIGHTING);
     for (x = 0 ; x < NB_CUBE_X ; x++)
        for (int y = 0 ; y < NB_CUBE_Y ; y++)
            for (int z = 0 ; z < NB_CUBE_Z ; z++)
                Cube[x][y][z]->Draw(0,-20,zz+20);
glPopMatrix();

void drawFloor()
{
   glColor4f(0.5f, 0.5f, 0.5f, 0.75f);
   glBegin(GL_QUADS);
      glVertex3f(0.0, 0.0, -20.0);
      glVertex3f(12.0, 0.0, -20.0);
      glVertex3f(12.0, 0.0, -70.0);
      glVertex3f(0.0, 0.0, -70.0);
   glEnd();
}

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glPushMatrix();
    gluLookAt(CUBE_R*NB_CUBE_X/2, 37, 30,CUBE_R*NB_CUBE_X/2, 36.7, 29 ,0, 1, 0);
    float zz=float(2*CUBE_R * (3 + 2*sin(tt/3000)));
    glDisable(GL_DEPTH_TEST);
    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
    glEnable(GL_STENCIL_TEST);
    glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
    glStencilFunc(GL_ALWAYS, 1, 0xffffffff);
       drawFloor();
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
    glEnable(GL_DEPTH_TEST);
    glStencilFunc(GL_EQUAL, 1, 0xffffffff);
    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
    glPushMatrix();
       glScalef(1.0, -1.0, 1.0);
       for (int x = 0 ; x < NB_CUBE_X ; x++)
          for (int y = 0 ; y < NB_CUBE_Y ; y++)
             for (int z = 0 ; z < NB_CUBE_Z ; z++)
             {
                   Cube[x][y][z]->Update(t);
                   Cube[x][y][z]->Draw(0,-20,zz+20);
              }
    glPopMatrix();
    glDisable(GL_STENCIL_TEST);
    glDisable(GL_LIGHTING);
    glDisable(GL_TEXTURE_2D);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
       drawFloor();
    glDisable(GL_BLEND);
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_LIGHTING);
    for (x = 0 ; x < NB_CUBE_X ; x++)
    for (int y = 0 ; y < NB_CUBE_Y ; y++)
    for (int z = 0 ; z < NB_CUBE_Z ; z++)
    Cube[x][y][z]->Draw(0,-20,zz+20);
glPopMatrix();

void shadowMatrix(GLfloat shadowMat[4][4], GLfloat groundplane[4], GLfloat lightpos[4])
{
    GLfloat dot;
    dot = groundplane[X] * lightpos[X] + groundplane[Y] * lightpos[Y] + groundplane[Z] * lightpos[Z] + groundplane[W] *   lightpos[W];

    shadowMat[0][0] = dot - lightpos[X] * groundplane[X];
    shadowMat[1][0] = 0.f - lightpos[X] * groundplane[Y];
    shadowMat[2][0] = 0.f - lightpos[X] * groundplane[Z];
    shadowMat[3][0] = 0.f - lightpos[X] * groundplane[W];

    shadowMat[X][1] = 0.f - lightpos[Y] * groundplane[X];
    shadowMat[1][1] = dot - lightpos[Y] * groundplane[Y];   
    shadowMat[2][1] = 0.f - lightpos[Y] * groundplane[Z];
    shadowMat[3][1] = 0.f - lightpos[Y] * groundplane[W];

    shadowMat[X][2] = 0.f - lightpos[Z] * groundplane[X];
    shadowMat[1][2] = 0.f - lightpos[Z] * groundplane[Y];
    shadowMat[2][2] = dot - lightpos[Z] * groundplane[Z];
    shadowMat[3][2] = 0.f - lightpos[Z] * groundplane[W];

    shadowMat[X][3] = 0.f - lightpos[W] * groundplane[X];
    shadowMat[1][3] = 0.f - lightpos[W] * groundplane[Y];
    shadowMat[2][3] = 0.f - lightpos[W] * groundplane[Z];
    shadowMat[3][3] = dot - lightpos[W] * groundplane[W];
}

/*  lÅíÌÇÏ ãÚÇÏáÉ ÓØÍ ÊÚØí ËáÇËÉ äÞÇØl  */
enum { X, Y, Z, W};
enum { A, B, C, D};
void findPlane(GLfloat plane[4], GLfloat v0[3], GLfloat v1[3], GLfloat v2[3])
{
    GLfloat vec0[3], vec1[3];
    /*  l ÇáÍÇÌÉ Åáì ÔÚÇÚíä áÅíÌÇÏ äÇÊÌ ÇáÚÈæÑ l   */ 
    vec0[X] = v1[X] - v0[X];
    vec0[Y] = v1[Y] - v0[Y];
    vec0[Z] = v1[Z] - v0[Z];
    vec1[X] = v2[X] - v0[X];
    vec1[Y] = v2[Y] - v0[Y];
    vec1[Z] = v2[Z] - v0[Z];
    /*  l ÅíÌÇÏ äÇÊÌ ÇáÚÈæÑ áÅÚØÇÁ ÇáÞíã Ã,È,Ì æ Ï áÏÇáÉ ÇáÓØÍl    */
    plane[A] = vec0[Y] * vec1[Z] - vec0[Z] * vec1[Y];
    plane[B] = -(vec0[X] * vec1[Z] - vec0[Z] * vec1[X];
    plane[C] = vec0[X] * vec1[Y] - vec0[Y] * vec1[X];
    plane[D] = -(plane[A] * v0[X] + plane[B] * v0[Y] + plane[C] * v0[Z]);
}

void drawFloor()
{
    GLfloat white[] = {1.0f, 1.0f, 1.0f, 1.0f};
    GLfloat floorc[] = {0.5f, 0.5f, 0.5f, 0.75f};

    glMaterialfv(GL_FRONT, GL_DIFFUSE, floorc);
    glMaterialfv(GL_FRONT, GL_SPECULAR, floorc);
    glBegin(GL_QUADS);
       glVertex3fv(vfloor[0]);
       glVertex3fv(vfloor[1]);
       glVertex3fv(vfloor[2]);
       glVertex3fv(vfloor[3]);
    glEnd();
    glMaterialfv(GL_FRONT, GL_DIFFUSE, white);
    glMaterialfv(GL_FRONT, GL_SPECULAR, white);
}

glDisable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   drawFloor();
glDisable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glStencilFunc(GL_ALWAYS, 2, 0xffffffff);
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
for (x = 0 ; x < NB_CUBE_X ; x++)
   for (int y = 0 ; y < NB_CUBE_Y ; y++)
      for (int z = 0 ; z < NB_CUBE_Z ; z++)
         Cube[x][y][z]->Draw(0,-20,zz+20);
glStencilFunc(GL_EQUAL, 1, 0xffffffff);
glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glColor4f(0.0, 0.0, 0.0, 0.5);
static GLfloat floorPlane[4];
static GLfloat floorShadow[4][4];
findPlane(floorPlane, vfloor[1], vfloor[2], vfloor[3]);
shadowMatrix(floorShadow, floorPlane, lightZeroPosition);
glPushMatrix();
    glMultMatrixf((GLfloat *) floorShadow);
    for (x = 0 ; x < NB_CUBE_X ; x++)
       for (int y = 0 ; y < NB_CUBE_Y ; y++)
          for (int z = 0 ; z < NB_CUBE_Z ; z++)
                  Cube[x][y][z]->Draw(0,-20,zz+20);
glPopMatrix();
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
glEnable(GL_LIGHTING);
glDisable(GL_STENCIL_TEST);