cube static method

Implementation

static Geometry cube(
    {bool normals = true, bool uvs = true, bool flipUvs = true}) {
  final vertices = Float32List.fromList([
    // Front face
    -1, -1, 1, // 0
    1, -1, 1, // 1
    1, 1, 1, // 2
    -1, 1, 1, // 3

    // Back face
    -1, -1, -1, // 4
    1, -1, -1, // 5
    1, 1, -1, // 6
    -1, 1, -1, // 7

    // Top face
    -1, 1, 1, // 3 (8)
    1, 1, 1, //2 (9)
    1, 1, -1, //6 (10)
    -1, 1, -1, // 7 (11)

    // Bottom
    -1, -1, -1, // 4 (12)
    1, -1, -1, // 5 (13)
    1, -1, 1, // 1 (14)
    -1, -1, 1, // 0 (15)

    // Right
    1, -1, 1, // 1 (16)
    1, -1, -1, // 5 (17)
    1, 1, -1, // 6 (18)
    1, 1, 1, // 2 (19)

    // Left
    -1, -1, -1, // 4 (20)
    -1, -1, 1, // 0 (21)
    -1, 1, 1, // 3 (22)
    -1, 1, -1 // 7 (23)
  ]);

  final _normals = normals
      ? Float32List.fromList([
          0,
          0,
          1,
          0,
          0,
          1,
          0,
          0,
          1,
          0,
          0,
          1,
          0,
          0,
          -1,
          0,
          0,
          -1,
          0,
          0,
          -1,
          0,
          0,
          -1,
          0,
          1,
          0,
          0,
          1,
          0,
          0,
          1,
          0,
          0,
          1,
          0,
          0,
          -1,
          0,
          0,
          -1,
          0,
          0,
          -1,
          0,
          0,
          -1,
          0,
          1,
          0,
          0,
          1,
          0,
          0,
          1,
          0,
          0,
          1,
          0,
          0,
          -1,
          0,
          0,
          -1,
          0,
          0,
          -1,
          0,
          0,
          -1,
          0,
          0,
        ])
      : null;

  // Original UV coordinates
  var originalUvs = <double>[
    // front
    1 / 3, 3 / 4, // 0
    2 / 3, 3 / 4, // 1
    2 / 3, 1, // 2
    1 / 3, 1, // 3

    // back
    1 / 3, 1 / 4, // 4
    2 / 3, 1 / 4, // 5
    2 / 3, 1 / 2, // 6
    1 / 3, 1 / 2, // 7

    // top
    2 / 3, 1 / 2, // 8
    1, 1 / 2, // 9
    1, 3 / 4, // 10
    2 / 3, 3 / 4, // 11

    // bottom
    0, 1 / 2, // 12
    1 / 3, 1 / 2, // 13
    1 / 3, 3 / 4, // 14
    0, 3 / 4, // 15

    // right
    1 / 3, 1 / 2, // 16
    2 / 3, 1 / 2, // 17
    2 / 3, 3 / 4, // 18
    1 / 3, 3 / 4, // 19

    // left
    1 / 3, 0, // 20
    2 / 3, 0, // 21
    2 / 3, 1 / 4, // 22
    1 / 3, 1 / 4 // 23
  ];

  // Apply UV flipping if requested
  final _uvs = uvs
      ? Float32List.fromList(
          flipUvs ? _flipUvCoordinates(originalUvs) : originalUvs)
      : null;

  final indices = [
    // Front face
    0, 1, 2, 0, 2, 3,
    // Back face
    5, 4, 7, 5, 7, 6,
    // Top face
    8, 9, 10, 8, 10, 11, // 3,2,6,3,6,7, //
    // Bottom face
    12, 13, 14, 12, 14, 15, // 4,5,1,4,1,0,
    // Right face
    16, 17, 18, 16, 18, 19, //1,5,6,1,6,2,
    // Left face
    20, 21, 22, 20, 22, 23 // 4,0,3,4,3,7
  ];

  return Geometry(vertices, Uint16List.fromList(indices), normals: _normals, uvs: _uvs);
}