static void rlgl_draw_mesh(Mesh mesh, Material material, Matrix transform)
{
    rlEnableShader(material.shader.id);

    // upload diffuse color
    if (material.shader.locs[SHADER_LOC_COLOR_DIFFUSE] != -1) {
        float diffuse[4];
        diffuse[0] = material.maps[MATERIAL_MAP_DIFFUSE].color.r / 255.0f;
        diffuse[1] = material.maps[MATERIAL_MAP_DIFFUSE].color.g / 255.0f;
        diffuse[2] = material.maps[MATERIAL_MAP_DIFFUSE].color.b / 255.0f;
        diffuse[3] = material.maps[MATERIAL_MAP_DIFFUSE].color.a / 255.0f;
        rlSetUniform(material.shader.locs[SHADER_LOC_COLOR_DIFFUSE],
                     diffuse, SHADER_UNIFORM_VEC4, 1);
    }

    // get current matrices
    Matrix mat_view = rlGetMatrixModelview();
    Matrix mat_projection = rlGetMatrixProjection();
    Matrix mat_model = MatrixMultiply(transform, rlGetMatrixTransform());

    // upload view and projection matrices
    if (material.shader.locs[SHADER_LOC_MATRIX_VIEW] != -1) {
        rlSetUniformMatrix(material.shader.locs[SHADER_LOC_MATRIX_VIEW], mat_view);
    }
    if (material.shader.locs[SHADER_LOC_MATRIX_PROJECTION] != -1) {
        rlSetUniformMatrix(material.shader.locs[SHADER_LOC_MATRIX_PROJECTION], mat_projection);
    }
    if (material.shader.locs[SHADER_LOC_MATRIX_MODEL] != -1) {
        rlSetUniformMatrix(material.shader.locs[SHADER_LOC_MATRIX_MODEL], mat_model);
    }

    // upload normal matrix (transpose of inverse of model matrix)
    if (material.shader.locs[SHADER_LOC_MATRIX_NORMAL] != -1) {
        Matrix mat_normal = MatrixTranspose(MatrixInvert(mat_model));
        rlSetUniformMatrix(material.shader.locs[SHADER_LOC_MATRIX_NORMAL], mat_normal);
    }

    // bind texture maps
    for (int i = 0; i < MAX_MATERIAL_MAPS; i++) {
        if (material.maps[i].texture.id > 0) {
            rlActiveTextureSlot(i);
            rlEnableTexture(material.maps[i].texture.id);
            rlSetUniform(material.shader.locs[SHADER_LOC_MAP_DIFFUSE + i],
                         &i, SHADER_UNIFORM_INT, 1);
        }
    }

    // bind VAO and draw
    rlEnableVertexArray(mesh.vaoId);

    // compute MVP matrix
    Matrix mat_model_view = MatrixMultiply(mat_model, mat_view);
    Matrix mat_mvp = MatrixMultiply(mat_model_view, mat_projection);
    rlSetUniformMatrix(material.shader.locs[SHADER_LOC_MATRIX_MVP], mat_mvp);

    // draw call
    if (mesh.indices != NULL) {
        rlDrawVertexArrayElements(0, mesh.triangleCount * 3, 0);
    } else {
        rlDrawVertexArray(0, mesh.vertexCount);
    }

    // unbind textures
    for (int i = 0; i < MAX_MATERIAL_MAPS; i++) {
        if (material.maps[i].texture.id > 0) {
            rlActiveTextureSlot(i);
            rlDisableTexture();
        }
    }

    rlDisableVertexArray();
    rlDisableVertexBuffer();
    rlDisableVertexBufferElement();
    rlDisableShader();

    // restore matrices
    rlSetMatrixModelview(mat_view);
    rlSetMatrixProjection(mat_projection);
}