how to generate cubes randomly in opengl / c#

Question

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.

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 < 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 < 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 < 4; j++)
                {
                    Gl.glVertex3d(point[faces[i, j]].X, point[faces[i, j]].Y, point[faces[i, j]].Z);
                }
                Gl.glEnd();
            }
            if (ymove >= -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);
        }
    }
}

You need to put a lot more effort into explaining what you are trying to achieve here. — Grimmy, May 24 '13 at 14:13
my main problem I need a function to generate cubes randomly with the three main colors red , green , and blue — Lara Dax, May 24 '13 at 14:24

score 0 · Answer 1 · answered May 24 '13 at 14:59

This is about data structure / organization than anything else. Since you know how to draw a cube you can start by making a Cube class. This is fairly trivial with immediate mode OpenGL (what you are using)

Since you know how to draw a cube, this class should be fairly easy :

class Cube
{
    // Member variables
    x,y,z position
    r,g,b color
    // Functions
    public Cube(position, color); // Constructor
    public draw(); // draw the cube
}

Then you need a structure that keeps the information about what you should be drawing.

class CubeGroup
{
    // Member variables
    private Cube[] cubes; // cube array
    // Member functions
    public AddCube(Cube in_cube); // Adds a cube
    public DeleteCube(int index); // Removes a cube
    public draw(); // Draws this group of cubes
    ....
}

You need at least some structures to help you achieving your goal. This makes you able to at least manage one set of cubes. You need to carefully think about what operations you want to do on your data and make structures that makes sense for this. It seems you want your data to change over time as well. Then you need some other structure to deal with that.

This is just pure speculation at this point, but hopefully it might lead you in the right direction. The classes here are just examples and in no way meant to be "the solution".

how to generate cubes randomly in opengl / c#

1 Answers1