Distorted Android

import org.distorted.library.mesh.AssociationUniformBlock;

    AssociationUniformBlock.setAssociationSize(params[0]);

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

// Copyright 2020 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

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

package org.distorted.library.mesh;

import android.opengl.GLES30;

import org.distorted.library.main.InternalBuffer;

import static org.distorted.library.mesh.MeshBase.MAX_EFFECT_COMPONENTS;

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

public class AssociationUniformBlock

  {

  private static int mAssociationSize = 8*MAX_EFFECT_COMPONENTS;

  private static final int DEFAULT_ASSOCIATION = 0xffffffff;

  private InternalBuffer mUBO;

  private int[] mAssociations;

  private int mAssociationBlock;

  private boolean mNeedAdjustAssociation;

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

/**

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

 *

 * @y.exclude

 */

  AssociationUniformBlock()

    {

    mNeedAdjustAssociation = true;

    mAssociationBlock = computeAssociationBlockSize();

    mAssociations= new int[mAssociationSize/4];

    for(int i=0; i<MAX_EFFECT_COMPONENTS; i++)

      {

      mAssociations[getAndIndex(i)] = DEFAULT_ASSOCIATION;

      mAssociations[getEquIndex(i)] = i;

      }

    mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ);

    }

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

  AssociationUniformBlock( AssociationUniformBlock original)

    {

    mNeedAdjustAssociation = original.mNeedAdjustAssociation;

    mAssociationBlock = original.mAssociationBlock;

    int size = original.mAssociations.length;

    mAssociations= new int[size];

    System.arraycopy(original.mAssociations, 0, mAssociations, 0, size);

    mUBO = new InternalBuffer(GLES30.GL_UNIFORM_BUFFER, GLES30.GL_STATIC_READ);

    }

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

/**

 * @y.exclude

 */

   public static void setAssociationSize(int size)

     {

     mAssociationSize = size;

     }

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

   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;

     mUBO.invalidate();

     }

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

   int getIndex()

     {

     if( mNeedAdjustAssociation )

       {

       mNeedAdjustAssociation = false;

       adjustAssociation();

       }

     return mUBO.createImmediatelyInt( mAssociationSize, mAssociations);

     }

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

   void copy( int compTo, AssociationUniformBlock assocFrom, int compFrom)

     {

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

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

     }

  }

           static final int MAX_EFFECT_COMPONENTS= 100;

   private AssociationUniformBlock mAUB;

     mAUB = new AssociationUniformBlock();

     mAUB = new AssociationUniformBlock(original.mAUB);

     for(int comp=0; comp<numComp; comp++)

       end   = mEffComponent.get(comp);

       if( mAUB.matchesAssociation(comp, andAssoc, equAssoc) )

     mAUB.setEffectAssociationNow(component, andAssociation, equAssociation);

           mAUB.copy(origEffComponents, mesh.mAUB, j);

     int index = mAUB.getIndex();