Consistent skinning uniforms across configurations and GLES

[ariankordi]

I'm trying to make my raylib app as cross-platform as I can without depending on compiler macros, and in doing this I faced issues with skinning in vertex shaders.

• IIRC there is no uniform set when GPU skinning is enabled or disabled
  If the user is linking raylib from a package where it's off by default, there's no way to know at runtime.
• Order of matrix uniforms differs between OpenGL ES and OpenGL Core
  This costed me hours and hours of debugging to get my app working on the web.

The second issue is addressed in the repo by using different shaders for each OpenGL version (330 vs 100), but even if you're willing to maintain those, you still can't share the same shader with skinned and unskinned meshes.

I've addressed these issues in my project with the following snippet:

typedef enum SkinningMode
{
    SkinningMode_None = 0,
    /// Matrices are uploaded in column-major order in OpenGL 3.3.
    SkinningMode_ColumnMajor = 1,
    /// Matrices are uploaded in column-major order in OpenGL ES 2.0/3.0.
    SkinningMode_RowMajor = 2,
} SkinningMode;

SkinningMode GetSkinningMode(const Mesh* mesh)
{
    // If vboId and boneIndices are allocated, the mesh has bones.
    bool enable = (mesh->vboId != NULL && mesh->boneIndices != NULL &&
        mesh->animVertices == NULL); // animVertices is only used for CPU skinning.

    if (enable)
    {
        switch (rlGetVersion())
        {
            // Raylib uploads the matrix non-transposed when
            // GRAPHICS_API_OPENGL_ES2 is defined (rlgl.h:rlSetUniformMatrices)
            case RL_OPENGL_ES_20: case RL_OPENGL_ES_30:
                return SkinningMode_RowMajor;
            default:
                return SkinningMode_ColumnMajor;
        }
    }
    else
    {
        return SkinningMode_None;
    }
}

Then in the vertex shader:

#version 100
#ifndef GL_ES
    #define attribute in
    #define varying out
#endif

precision highp float;
attribute vec3 vertexPosition;
attribute vec2 vertexTexCoord;
attribute vec4 vertexBoneIndices;
attribute vec4 vertexBoneWeights;

varying vec2 fragTexCoord;

uniform mat4 mvp;
uniform mat4 boneMatrices[64];
uniform int skinningMode;

// Get row-major matrix into GLSL column-major representation.
// Note that this is needed because on upload, Raylib
// does not transpose the matrix for GLES.
mat4 getBoneMatrix(int boneIndex)
{
    return skinningMode == 2 // SkinningMode_RowMajor
    ? mat4(
        vec4(boneMatrices[boneIndex][0].x,
                boneMatrices[boneIndex][1].x,
                boneMatrices[boneIndex][2].x,
                boneMatrices[boneIndex][3].x),
        vec4(boneMatrices[boneIndex][0].y,
                boneMatrices[boneIndex][1].y,
                boneMatrices[boneIndex][2].y,
                boneMatrices[boneIndex][3].y),
        vec4(boneMatrices[boneIndex][0].z,
                boneMatrices[boneIndex][1].z,
                boneMatrices[boneIndex][2].z,
                boneMatrices[boneIndex][3].z),
        vec4(boneMatrices[boneIndex][0].w,
                boneMatrices[boneIndex][1].w,
                boneMatrices[boneIndex][2].w,
                boneMatrices[boneIndex][3].w)
    ) : boneMatrices[boneIndex]; // Column-major order
}

void main()
{
    vec4 skinnedPosition = vec4(vertexPosition, 1.0);

    if (skinningMode != 0) // SkinningMode_None
    {
        mat4 bone0 = getBoneMatrix(int(vertexBoneIndices.x));
        mat4 bone1 = getBoneMatrix(int(vertexBoneIndices.y));
        mat4 bone2 = getBoneMatrix(int(vertexBoneIndices.z));
        mat4 bone3 = getBoneMatrix(int(vertexBoneIndices.w));

        skinnedPosition =
            vertexBoneWeights.x * (bone0 * skinnedPosition) +
            vertexBoneWeights.y * (bone1 * skinnedPosition) +
            vertexBoneWeights.z * (bone2 * skinnedPosition) +
            vertexBoneWeights.w * (bone3 * skinnedPosition);
    }

    gl_Position = mvp * skinnedPosition;
    fragTexCoord = vertexTexCoord;
}

Usage: Run GetSkinningMode on each mesh you want to draw (or I suppose the first mesh in a model), then set skinningMode on the shader accordingly.
(The shader does not account for vertex weights, normals, or tangents. This means it'll only work with simple skins. Should be an easy fix, though.)

I really hope these problems can be addressed in the project at some point, but for the time being, this lets me write shaders once and work across GLES 2 + GL Core 3.3.