void pack()

in wasm/data.cpp [74:140]

• 54 lines of code
• 4 McCabe index (conditional complexity)

void pack(bool selected, uint32_t vertexCount, float *positions, float *rotations, float *scales, uint8_t *colors,
          uint8_t *selection, uint32_t *data, float *worldPositions, float *worldRotations, float *worldScales) {
    float rot[4];
    float rotMat[9];
    float scaleMat[9] = {0};
    float M[9];
    float sigma[6];

    for (uint32_t i = 0; i < vertexCount; i++) {
        float x = positions[i * 3 + 0];
        float y = positions[i * 3 + 1];
        float z = positions[i * 3 + 2];

        worldPositions[i * 3 + 0] = x;
        worldPositions[i * 3 + 1] = y;
        worldPositions[i * 3 + 2] = z;

        data[8 * i + 0] = *(uint32_t *)&x;
        data[8 * i + 1] = *(uint32_t *)&y;
        data[8 * i + 2] = *(uint32_t *)&z;

        data[8 * i + 3] = 0;
        if (selected || selection[i] > 0) {
            data[8 * i + 3] |= 0x01000000;
        }

        uint32_t color = 0;
        color |= (uint32_t)colors[i * 4 + 0] << 0;
        color |= (uint32_t)colors[i * 4 + 1] << 8;
        color |= (uint32_t)colors[i * 4 + 2] << 16;
        color |= (uint32_t)colors[i * 4 + 3] << 24;
        data[8 * i + 7] = color;

        rot[0] = rotations[i * 4 + 1];
        rot[1] = rotations[i * 4 + 2];
        rot[2] = rotations[i * 4 + 3];
        rot[3] = -rotations[i * 4 + 0];

        quaternionToMatrix3(rot, rotMat);

        worldRotations[i * 4 + 0] = rot[0];
        worldRotations[i * 4 + 1] = rot[1];
        worldRotations[i * 4 + 2] = rot[2];
        worldRotations[i * 4 + 3] = rot[3];

        scaleMat[0] = scales[i * 3 + 0];
        scaleMat[4] = scales[i * 3 + 1];
        scaleMat[8] = scales[i * 3 + 2];

        worldScales[i * 3 + 0] = scaleMat[0];
        worldScales[i * 3 + 1] = scaleMat[4];
        worldScales[i * 3 + 2] = scaleMat[8];

        multiplyMatrix3(scaleMat, rotMat, M);

        sigma[0] = M[0] * M[0] + M[3] * M[3] + M[6] * M[6];
        sigma[1] = M[0] * M[1] + M[3] * M[4] + M[6] * M[7];
        sigma[2] = M[0] * M[2] + M[3] * M[5] + M[6] * M[8];
        sigma[3] = M[1] * M[1] + M[4] * M[4] + M[7] * M[7];
        sigma[4] = M[1] * M[2] + M[4] * M[5] + M[7] * M[8];
        sigma[5] = M[2] * M[2] + M[5] * M[5] + M[8] * M[8];

        data[8 * i + 4] = packHalf2x16(4 * sigma[0], 4 * sigma[1]);
        data[8 * i + 5] = packHalf2x16(4 * sigma[2], 4 * sigma[3]);
        data[8 * i + 6] = packHalf2x16(4 * sigma[4], 4 * sigma[5]);
    }
}