Vertex Shaders - Praise for OpenGL ES 30 Programming Guide - page 208

gl_MaxVertexUniformVectors that is supported by all OpenGL ES 3.0
implementations is 256 vec4 entries. Thus we will have only the fourth
row of these 256 vec4 uniform entries available. This row of floating-
point values can store only uniforms declared to be of type float (as
per the uniform packing rule). There is no room, therefore, to store a
vec2 , vec3 , or vec4 uniform. It would be better to store the matrices in
the palette in row-major order using three vec4 entries per matrix. If
we did this, then we would use 96 vec4 entries of uniform storage and
the remaining 160 vec4 entries could be used to store other uniforms.
Note that we do not have enough uniform storage to store the inverse
transpose matrices needed to compute the skinned normal. This is
typically not a problem, however: In most cases, the matrices used
are orthonormal and, therefore, can be used to transform the vertex
position and the normal.

Example 8-6 shows the vertex shader code that computes the skinned
normal and position. We assume that the matrix palette contains
32 matrices, and that these matrices are stored in row-major order. The
matrices are also assumed to be orthonormal (i.e., the same matrix can be
used to transform position and normal) and up to four matrices are used
to transform each vertex.

Example 8-6 Vertex Skinning Shader with No Check of Whether

Matrix Weight = 0

#version 300 es

#define NUM_MATRICES 32 // 32 matrices in matrix palette

const int c_zero = 0;
const int c_one = 1;
const int c_two = 2;
const int c_three = 3;

// store 32 4 x 3 matrices as an array of floats representing
// each matrix in row-major order (i.e., 3 vec4s)
uniform vec4 matrix_palette[NUM_MATRICES * 3];

// vertex position and normal attributes
in vec4 a_position;
in vec3 a_normal;

// matrix weights - 4 entries / vertex
in vec4 a_matrixweights;
// matrix palette indices
in vec4 a_matrixindices;