function computeOrderMask(outlineCoordinates, vertexIndex, a, b, c) {
  const startIndex = vertexIndex * 3;
  const first = outlineCoordinates[startIndex];
  const second = outlineCoordinates[startIndex + 1];
  const third = outlineCoordinates[startIndex + 2];

  // If one coordinate is undefined, they all are since matchAndStoreCoordinates sets
  // all 3 components at once. In this case, all orderings are fine.
  if (!defined(first)) {
    return 0b111111;
  }

  return (
    ((first === a && second === b && third === c) << 0) |
    ((first === a && second === c && third === b) << 1) |
    ((first === b && second === a && third === c) << 2) |
    ((first === b && second === c && third === a) << 3) |
    ((first === c && second === a && third === b) << 4) |
    ((first === c && second === b && third === a) << 5)
  );
}
Each vertex has three coordinates, a, b, and c.
a is the coordinate that applies to edge 2-0 for the vertex.
b is the coordinate that applies to edge 0-1 for the vertex.
c is the coordinate that applies to edge 1-2 for the vertex.

A single triangle with all edges highlighted:

                | a | b | c |
                | 1 | 1 | 0 |
                      0
                     / \
                    /   \
          edge 0-1 /     \ edge 2-0
                  /       \
                 /         \
| a | b | c |   1-----------2   | a | b | c |
| 0 | 1 | 1 |     edge 1-2      | 1 | 0 | 1 |

There are 6 possible orderings of coordinates a, b, and c:
0 - abc
1 - acb
2 - bac
3 - bca
4 - cab
5 - cba

All vertices must use the _same ordering_ for the edges to be rendered
correctly. So we compute a bitmask for each vertex, where the bit at
each position indicates whether that ordering works (i.e. doesn't
conflict with already-assigned coordinates) for that vertex.

Then we can find an ordering that works for all three vertices with a
bitwise AND.

@param {number[]} outlineCoordinates The array of outline coordinates
@param {number} vertexIndex The index of the vertex to compute the mask for
@param {number} a The outline coordinate for edge 2-0
@param {number} b The outline coordinate for edge 0-1
@param {number} c The outline coordinate for edge 1-2
@returns {number} A bitmask with 6 bits where a 1 indicates the corresponding ordering is valid.

@private