Distorted Android

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

  public int getNumEffectsToBe()

    {

    return mNumEffectsToBe;

    }

import org.distorted.library.type.Static4D;

import android.util.Log;

  private static final int JOB_TYPE_TEXTURE= 4;

    private Static4D[] mMaps;

    Job(int type, MeshBase target, MeshBase[] source, VertexEffect effect, Static4D[] maps)

      mMaps   = maps;

        case JOB_TYPE_VERTEX : DistortedLibrary.adjustVertices(mTarget, mEffects);

                               //Log.e("jobs", "executing vertex job");

                               //mTarget.print();

                               break;

        case JOB_TYPE_MERGE  : mTarget.merge();

                               //Log.e("jobs", "executing merge job");

                               //mTarget.print();

                               break;

        case JOB_TYPE_JOIN   : mTarget.joinAttribs(mSource);

                               //Log.e("jobs", "executing join job");

                               //mTarget.print();

                               break;

        case JOB_TYPE_COPY   : mTarget.copy(mSource[0]);

                               //Log.e("jobs", "executing copy job");

                               //mTarget.print();

                               break;

        case JOB_TYPE_TEXTURE: mTarget.textureMap(mMaps);

                               //Log.e("jobs", "executing textureMap job");

                               //mTarget.print();

                               break;

    String print()

      {

      switch(mType)

        {

        case JOB_TYPE_VERTEX : return "VERTEX (eff: "+mEffects.getNumEffects()+" effToBe: "+mEffects.getNumEffectsToBe()+")";

        case JOB_TYPE_MERGE  : return "MERGE";

        case JOB_TYPE_JOIN   : return "JOIN: "+mSource.length;

        case JOB_TYPE_COPY   : return "COPY";

        case JOB_TYPE_TEXTURE: return "TEXTURE";

        }

      return null;

      }

        node = mPrevJobs.get(0);  // removeNode() rips the executed job out, thus the 0

    void print(int level)

      {

      int numPrev = mPrevJobs.size();

      int numNext = mNextJobs.size();

      String str = "";

      for(int i=0; i<level; i++) str+=" ";

      str += mJob.print();

      str += (" next: "+numNext+" prev: "+numPrev);

      Log.e("job", str);

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

        {

        JobNode node = mPrevJobs.get(i);

        node.print(level+1);

        }

      }

      Job job = new Job(JOB_TYPE_VERTEX,target,null,effect,null);

        Job job = new Job(JOB_TYPE_VERTEX,target,null,effect,null);

    Job job = new Job(JOB_TYPE_MERGE,target,null,null,null);

  static JobNode join(MeshBase target, MeshBase[] meshes)

    Job job = new Job(JOB_TYPE_JOIN,target,meshes,null,null);

      if( jn!=null )

        {

        node.mPrevJobs.add(jn);

        jn.mNextJobs.add(node);

        }

    Job job = new Job(JOB_TYPE_COPY,target,meshes,null,null);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode textureMap(MeshBase target, Static4D[] maps)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_TEXTURE,target,null,null,maps);

     mShowNormals= original.mShowNormals;

     mInflate    = original.mInflate;

     mNumVertices= original.mNumVertices;

       if( original.mJobNode[0]==null ) copy(original);

       else mJobNode[0] = DeferredJobs.copy(this,original);

       shallowCopy(original);

   void copy(MeshBase original)

     shallowCopy(original);

     mVBO1= new InternalBuffer(GLES30.GL_ARRAY_BUFFER, GLES30.GL_STATIC_READ);

     mVertAttribs1= new float[mNumVertices*VERT1_ATTRIBS];

     System.arraycopy(original.mVertAttribs1,0,mVertAttribs1,0,mNumVertices*VERT1_ATTRIBS);

     mVBO1.invalidate();

   private void shallowCopy(MeshBase original)

     int size = original.mComponent.size();

     mComponent = new ArrayList<>();

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

       {

       Component comp = new Component(original.mComponent.get(i));

       mComponent.add(comp);

       }

     mVBO2= new InternalBuffer(GLES30.GL_ARRAY_BUFFER, GLES30.GL_STATIC_READ);

     mVertAttribs2= new float[mNumVertices*VERT2_ATTRIBS];

     System.arraycopy(original.mVertAttribs2,0,mVertAttribs2,0,mNumVertices*VERT2_ATTRIBS);

     mVBO2.invalidate();

   void joinAttribs(MeshBase[] meshes)

     Component comp;

     int origVertices = mNumVertices;

     int origComponents=0,numComponents,numVertices;

       origComponents = mComponent.size();

       mNumVertices+= ( mNumVertices%2==1 ? 2:1 );

       mComponent.get(origComponents-1).mEndIndex = mNumVertices-1;

       numComponents = mesh.mComponent.size();

       int extraVerticesBefore = mNumVertices==0 ? 0:1;

       int extraVerticesAfter  = (i==numMeshes-1) ? 0 : (numVertices%2==1 ? 2:1);

       for(int j=0; j<numComponents; j++)

         comp = new Component(mesh.mComponent.get(j));

         comp.mEndIndex += (extraVerticesBefore+mNumVertices+extraVerticesAfter);

         mComponent.add(comp);

         if( origComponents<MAX_COMPONENTS )

           mAssociation[origComponents] = mesh.mAssociation[j];

           origComponents++;

       mNumVertices += (extraVerticesBefore+numVertices+extraVerticesAfter);

       }

     float[] newAttribs1 = new float[VERT1_ATTRIBS*mNumVertices];

     numVertices = origVertices;

       System.arraycopy(mVertAttribs1,                              0, newAttribs1,                         0, VERT1_ATTRIBS*numVertices);

       System.arraycopy(mVertAttribs1, VERT1_ATTRIBS*(origVertices-1), newAttribs1, VERT1_ATTRIBS*origVertices, VERT1_ATTRIBS    );

         System.arraycopy(mVertAttribs1, VERT1_ATTRIBS*(origVertices-1), newAttribs1, VERT1_ATTRIBS*origVertices, VERT1_ATTRIBS);

         System.arraycopy(mesh.mVertAttribs1, 0, newAttribs1, VERT1_ATTRIBS*origVertices, VERT1_ATTRIBS    );

       System.arraycopy(mesh.mVertAttribs1, 0, newAttribs1, VERT1_ATTRIBS*origVertices, VERT1_ATTRIBS*numVertices);

         System.arraycopy(mesh.mVertAttribs1, VERT1_ATTRIBS*(numVertices-1), newAttribs1, VERT1_ATTRIBS*origVertices, VERT1_ATTRIBS);

           System.arraycopy(mesh.mVertAttribs1, VERT1_ATTRIBS*(numVertices-1), newAttribs1, VERT1_ATTRIBS*origVertices, VERT1_ATTRIBS);

     mVertAttribs1 = newAttribs1;

     mVBO1.invalidate();

     boolean immediateJoin = true;

     for (MeshBase mesh : meshes)

       if (mesh.mJobNode[0] != null)

         {

         immediateJoin = false;

         break;

         }

     if( immediateJoin ) joinAttribs(meshes);

     else                mJobNode[0] = DeferredJobs.join(this,meshes);

     }

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

   void textureMap(Static4D[] maps)

     {

     int num_comp = mComponent.size();

     int num_maps = maps.length;

     int min = Math.min(num_comp, num_maps);

     int vertex = 0;

     Static4D newMap, oldMap;

     Component comp;

     float newW, newH, ratW, ratH, movX, movY;

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

       {

       newMap = maps[i];

       comp = mComponent.get(i);

       if( newMap!=null )

         newW = newMap.get2();

         newH = newMap.get3();

         if( newW!=0.0f && newH!=0.0f )

           oldMap = comp.mTextureMap;

           ratW = newW/oldMap.get2();

           ratH = newH/oldMap.get3();

           movX = newMap.get0() - ratW*oldMap.get0();

           movY = newMap.get1() - ratH*oldMap.get1();

           for( int index=vertex*VERT2_ATTRIBS+TEX_ATTRIB ; vertex<=comp.mEndIndex; vertex++, index+=VERT2_ATTRIBS)

             {

             mVertAttribs2[index  ] = ratW*mVertAttribs2[index  ] + movX;

             mVertAttribs2[index+1] = ratH*mVertAttribs2[index+1] + movY;

             }

           comp.setMap(newMap);

       vertex= comp.mEndIndex+1;

     mVBO2.invalidate();

     }

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

   public static int getMaxComponents()

     {

     return MAX_COMPONENTS;

     }

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

   public static void getUniforms(int mProgramH, int variant)

     {

     mComponentAssociationH[variant] = GLES30.glGetUniformLocation( mProgramH, "vComponAssoc");

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

/**

 * Not part of public API, do not document (public only because has to be used from the main package)

 *

 * @y.exclude

 */

   public void debug()

     {

     if( mJobNode[0]!=null )

       {

       mJobNode[0].print(0);

       }

     else

       {

       android.util.Log.e("mesh", "JobNode null");

       }

     }

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

/**

 * Not part of public API, do not document (public only because has to be used from the main package)

 *

 * @y.exclude

 */

   public void print()

     {

     StringBuffer sb = new StringBuffer();

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

       {

       sb.append('(');

       sb.append(mVertAttribs1[VERT1_ATTRIBS*i+POS_ATTRIB  ]);

       sb.append(',');

       sb.append(mVertAttribs1[VERT1_ATTRIBS*i+POS_ATTRIB+1]);

       sb.append(',');

       sb.append(mVertAttribs1[VERT1_ATTRIBS*i+POS_ATTRIB+2]);

       sb.append(") ");

       }

     StringBuffer sb2 = new StringBuffer();

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

       {

       sb2.append(mVertAttribs2[VERT2_ATTRIBS*i+COM_ATTRIB]);

       sb2.append(' ');

       }

     Log.d("mesh", sb.toString()+"\n"+sb2.toString());

     }

     if( mJobNode[0]==null )

     if( mJobNode[0]==null )

       textureMap(maps);

       }

     else

       {

       mJobNode[0] = DeferredJobs.textureMap(this,maps);