Distorted Android

import org.distorted.library.mesh.AssociationUniformBlock;

    int[] params = new int[1];

    int index = GLES30.glGetUniformBlockIndex(mMainProgramH, "meshAssociation");

    GLES30.glGetActiveUniformBlockiv( mMainProgramH, index, GLES30.GL_UNIFORM_BLOCK_DATA_SIZE, params, 0);

    AssociationUniformBlock.setAssociationSize(params[0]);

public class AssociationUniformBlock

  private static int mAssociationSize = 8*MAX_EFFECT_COMPONENTS;

  private int mAssociationBlock;

  private boolean mNeedAdjustAssociation;

/**

 * Public only because DistortedLibrary needs to see this to call setAssociationSize

 *

 * @y.exclude

 */

    mNeedAdjustAssociation = true;

    mAssociationBlock = computeAssociationBlockSize();

    mAssociations= new int[mAssociationSize/4];

      mAssociations[getAndIndex(i)] = DEFAULT_ASSOCIATION;

      mAssociations[getEquIndex(i)] = i;

    mNeedAdjustAssociation = original.mNeedAdjustAssociation;

    mAssociationBlock = original.mAssociationBlock;

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * @y.exclude

 */

   public static void setAssociationSize(int size)

     {

     if( size>0 ) mAssociationSize = size;  // if we are not using any VertexEffects, there

                                            // will be no 'meshAssociation' UBO in the shader,

                                            // and thus its detected size will be 0. Do not change

                                            // the initial guess then - we still might need the

                                            // associations for applying the MatrixEffects to a

                                            // mesh, for one.

     }

   private int getAndIndex(int component)

     return mAssociationBlock*component;

   private int getEquIndex(int component)

     return mAssociationBlock*(MAX_EFFECT_COMPONENTS+component);

     }

///////////////////////////////////////////////////////////////////////////////////////////////////

   private int computeAssociationBlockSize()

     {

     return 1 + (mAssociationSize/4 - 2*MAX_EFFECT_COMPONENTS) / (2*MAX_EFFECT_COMPONENTS-1);

     }

///////////////////////////////////////////////////////////////////////////////////////////////////

   private int getAndAssoc(int comp)

     {

     return mAssociations[getAndIndex(comp)];

     }

///////////////////////////////////////////////////////////////////////////////////////////////////

   private int getEquAssoc(int comp)

     {

     return mAssociations[getEquIndex(comp)];

     }

///////////////////////////////////////////////////////////////////////////////////////////////////

// The problem here is that at MeshBase object creation time, we might not know the size of the

// 'meshAssociation' Uniform Block Object in the vertex shader (the UBO is packed according to the

// 'shared' layout, which means the size of the block is known only after linking the shaders).

//

// We thus, in the constructor, guess that the layout will be tight (so we will need 8*MAX_EFFECT_C

// bytes there), allocate mAssociation already, and if later on, as a result of linking the shaders,

// we get a call to setAssociationSize() which changes the size to something else, we need to reallocate.

//

// It can happen that even before the linking the value of mAssociationSize is already 'right' because

// this is a static variable and it might persist from an earlier run. All the better then; this should

// never be wrong.

   private void adjustAssociation()

     {

     int oldLen = mAssociations.length;

     if( mAssociationSize != 4*oldLen )

       {

       int[] tmp = new int[oldLen];

       System.arraycopy(mAssociations, 0, tmp, 0, oldLen);

       int newLen = mAssociationSize/4;

       mAssociations = new int[newLen];

       mAssociationBlock = computeAssociationBlockSize();

       for(int i=0; i<oldLen/2; i++)

         {

         mAssociations[getAndIndex(i)] = tmp[i];                         // oldLen must be equal to

         mAssociations[getEquIndex(i)] = tmp[MAX_EFFECT_COMPONENTS+i];   // 8*MAX_EFFECT_COM

         }

       }

     }

///////////////////////////////////////////////////////////////////////////////////////////////////

   boolean matchesAssociation( int component, int andAssoc, int equAssoc)

     {

     return (andAssoc & mAssociations[getAndIndex(component)]) != 0 || (equAssoc == mAssociations[getEquIndex(component)]);

     }

///////////////////////////////////////////////////////////////////////////////////////////////////

   void setEffectAssociationNow(int component, int andAssociation, int equAssociation)

     {

     mAssociations[getAndIndex(component)] = andAssociation;

     mAssociations[getEquIndex(component)] = equAssociation;

     if( mNeedAdjustAssociation )

       {

       mNeedAdjustAssociation = false;

       adjustAssociation();

       }

     return mUBO.createImmediatelyInt( mAssociationSize, mAssociations);

     mAssociations[getAndIndex(compTo)] = assocFrom.getAndAssoc(compFrom);

     mAssociations[getEquIndex(compTo)] = assocFrom.getEquAssoc(compFrom);

   private static final int UBO_BINDING = 1;

layout (shared, binding=1) uniform meshAssociation

  int vComAndAssoc[MAX_COMPON]; // 'logical AND' association of the component.

  int vComEquAssoc[MAX_COMPON]; // 'equal' association of the component.

    if( ((vComAndAssoc[component] & vEffAndAssoc[i]) != 0) || (vComEquAssoc[component] == vEffEquAssoc[i]) )