Elegant way the find the Vertices of a Cube

Question

Nearly every OpenGL tutorial lets you implement drawing a cube. Therefore the vertices of the cube are needed. In the example code I saw a long list defining every vertex. But I would like to compute the vertices of a cube rather that using a overlong list of precomputed coordinates.

A cube is made of eight vertices and twelve triangles. Vertices are defined by x, y, and z. Triangles are defined each by the indexes of three vertices.

Is there an elegant way to compute the vertices and the element indexes of a cube?

Answer 1

When i was "porting" the csg.js project to Java I've found some cute code which generated cube with selected center point and radius. (I know it's JS, but anyway)

// Construct an axis-aligned solid cuboid. Optional parameters are `center` and
// `radius`, which default to `[0, 0, 0]` and `[1, 1, 1]`. The radius can be
// specified using a single number or a list of three numbers, one for each axis.
// 
// Example code:
// 
//     var cube = CSG.cube({
//       center: [0, 0, 0],
//       radius: 1
//     });
CSG.cube = function(options) {
  options = options || {};
  var c = new CSG.Vector(options.center || [0, 0, 0]);
  var r = !options.radius ? [1, 1, 1] : options.radius.length ?
           options.radius : [options.radius, options.radius, options.radius];
  return CSG.fromPolygons([
    [[0, 4, 6, 2], [-1, 0, 0]],
    [[1, 3, 7, 5], [+1, 0, 0]],
    [[0, 1, 5, 4], [0, -1, 0]],
    [[2, 6, 7, 3], [0, +1, 0]],
    [[0, 2, 3, 1], [0, 0, -1]],
    [[4, 5, 7, 6], [0, 0, +1]]
  ].map(function(info) {
    return new CSG.Polygon(info[0].map(function(i) {
      var pos = new CSG.Vector(
        c.x + r[0] * (2 * !!(i & 1) - 1),
        c.y + r[1] * (2 * !!(i & 2) - 1),
        c.z + r[2] * (2 * !!(i & 4) - 1)
      );
      return new CSG.Vertex(pos, new CSG.Vector(info[1]));
    }));
  }));
};

Answer 2

I solved this problem with this piece code (C#):

public CubeShape(Coord3 startPos, int size) {
    int l = size / 2;
    verts = new Coord3[8];
    for (int i = 0; i < 8; i++) {
        verts[i] = new Coord3(
            (i & 4) != 0 ? l : -l,
            (i & 2) != 0 ? l : -l,
            (i & 1) != 0 ? l : -l) + startPos;
    }

    tris = new Tris[12];
    int vertCount = 0;
    void AddVert(int one, int two, int three) =>
        tris[vertCount++] = new Tris(verts[one], verts[two], verts[three]);
        
    for (int i = 0; i < 3; i++) {
        int v1 = 1 << i;
        int v2 = v1 == 4 ? 1 : v1 << 1;
        AddVert(0, v1, v2);
        AddVert(v1 + v2, v2, v1);
        AddVert(7, 7 - v2, 7 - v1);
        AddVert(7 - (v1 + v2), 7 - v1, 7 - v2);
    }
}

If you want to understand more of what is going on, you can check out the github page I wrote that explains it.