title: how to generate cubes randomly in opengl / c#
body: <p>I'm trying to build a game 'blocks' which sees the matches cubes and delete them.
  This code makes two cubes and moves them along the y-axis. Then, it supposed to disappear and 100 cube in different places to appear. My problem is I don't know how to make the cubes look disappearing nor how to write the function 'cube generation' , I'm writing in 3d.
  Any help of what should I do.</p>
  
  <pre><code>using System;   
  using System.Collections.Generic;
  using System.ComponentModel;
  using System.Data;
  using System.Drawing;
  using System.Linq;
  using System.Text;
  using System.Windows.Forms;
  using Tao.OpenGl;
  using System.Threading;
  using Tao.FreeGlut;
  namespace TAOSample
  {
       class VertexDania{
          double vx, vy , vz;
  
          public double  X{
  
              get{return vx;}
              set{ vx = value;}
          }
          public double  Y{
              get{return vy;}
              set{ vy = value;}
          }
                   public double Z{
              get{return vz;}
              set{ vz = value;}
          }
      } 
      public partial class Form1 : Form
      {
           public Form1()
          {
  InitializeComponent();
              simpleOpenGlControl1.InitializeContexts();
              Gl.glClearColor(1, 1, 0, 0);
              Gl.glClearDepth(1.0);
              Gl.glMatrixMode(Gl.GL_PROJECTION);
              Gl.glLoadIdentity();
  
              Glu.gluPerspective(45, simpleOpenGlControl1.Height /(double)simpleOpenGlControl1.Width, 0.1, 1000);
              Gl.glViewport(0, 0, simpleOpenGlControl1.Width, simpleOpenGlControl1.Height);
  
              Tao.FreeGlut.Glut.glutInit();
  
          } 
   private void simpleOpenGlControl1_Paint(object sender, PaintEventArgs e)
          {
  
              Gl.glEnable(Gl.GL_LIGHTING);
              Gl.glEnable(Gl.GL_LIGHT0);
              Gl.glEnable(Gl.GL_COLOR_MATERIAL);
   Gl.glEnable(Gl.GL_DEPTH_TEST);
              Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
              Gl.glLoadIdentity();
  
   VertexDania[] points = new VertexDania[]
              {
                  new VertexDania{X=0     , Y=0.73  , Z=-0.75},
                  new VertexDania{X=0.1   , Y=0.85  , Z=-0.75},
                  new VertexDania{X=-0.01 , Y=0.95   , Z=-0.75},
                  new VertexDania{X=-0.1  , Y=0.80  , Z=-0.75},
                  new VertexDania{X=0.1   , Y=0.65  , Z=-1},
                  new VertexDania{X=0     , Y=0.5   , Z=-0.75},
                  new VertexDania{X=-0.1  , Y=0.6  , Z=-1}    
              };
              VertexDania[] point = new VertexDania[]
              {
                  new VertexDania{X=0, Y=0.23, Z=-0.75},
                  new VertexDania{X=0.1 , Y=0.35 , Z=-0.75},
                  new VertexDania{X=-0.01 , Y=0.45 , Z=-0.75},
                  new VertexDania{X=-0.1 , Y=0.30 , Z=-0.75},
                  new VertexDania{X=0.1 , Y=0.1 , Z=-0.75},
                  new VertexDania{X=0 , Y=0.0 , Z=-0.75},
                  new VertexDania{X=-0.1, Y=0.1, Z=-0.75}
              };
              double[,] normals = new double[,]
              {
                  {0,0,1},
                  {0,0,-1},
                  {0,0,-1}
              };
              int[,] faces = new int[,]
              {
                  {0 , 1 ,4 , 5},
                  {0 , 3 , 6 , 5},
                  {0, 3 , 2 , 1}
              };
  
              Gl.glColor3d(1, 0, 0);
              Gl.glTranslated(0, ymove, 0.1);
              for (int i = 0; i &lt; faces.GetLength(0); i++)
              {
  
                  Gl.glNormal3d(normals[i, 0], normals[i, 1], normals[i, 2]);
                  Gl.glBegin(Gl.GL_QUADS);
                  for (int j = 0; j &lt; 4; j++)
                  {
                      Gl.glVertex3d(points[faces[i, j]].X, points[faces[i, j]].Y, points[faces[i, j]].Z);
                  }
                  Gl.glEnd();
                  Gl.glNormal3d(normals[i, 0], normals[i, 1], normals[i, 2]);
                  Gl.glBegin(Gl.GL_QUADS);
                  for (int j = 0; j &lt; 4; j++)
                  {
                      Gl.glVertex3d(point[faces[i, j]].X, point[faces[i, j]].Y, point[faces[i, j]].Z);
                  }
                  Gl.glEnd();
              }
              if (ymove &gt;= -3)
                  ymove -= 0.03;
     }
   void redrawThread()
          {
              while (true)
              {
                  Thread.Sleep(50);
                  simpleOpenGlControl1.Invoke(new Action(delegate()
                  {
                      simpleOpenGlControl1.Draw();
                  }));
              }
          }
  
          private void Form1_Load(object sender, EventArgs e)
          {
              Thread t = new Thread(redrawThread);
              t.IsBackground = true;
              t.Start();
          }
  
          private void simpleOpenGlControl1_Resize(object sender, EventArgs e)
          {
              Gl.glMatrixMode(Gl.GL_PROJECTION);
              Gl.glLoadIdentity();
              Glu.gluPerspective(45, simpleOpenGlControl1.Width / (double)simpleOpenGlControl1.Height, 0.1, 100);
              Gl.glViewport(0, 0, simpleOpenGlControl1.Width, simpleOpenGlControl1.Height);
             // Gl.glMatrixMode(Gl.GL_MODELVIEW);
          }
      }
  }
  </code></pre>