Distorted Android

  private final static int[]   mUnityDim = new int[NUM_EFFECTS];

  int mAssociation;

  static boolean[] mEnabled = new boolean[NUM_EFFECTS];

    mRegionDim = name.getRegionDimension();

    mAssociation = 0xffffffff;

    int n = name.ordinal();

    float[] u = name.getUnity();

    return mAssociation;

    }

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

// PUBLIC API

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

    {

    return

          "{\n" +

           code +"\n" +

          "}\n" +

 *

 * This creates an association between this Vertex Effect and a Component of a Mesh.

 * One can set the association of an Effect and of a Component, and the Effect will only be active on

 *

 * The point: this way we can configure the system so that each Vertex Effect acts only on a certain

 * subset of a Mesh, thus potentially significantly reducing the number of render calls.

 */

    {

    mAssociation = association;

    }

  }

 */

public abstract class EffectQueue implements InternalMaster.Slave

  {

  private static final int CREATE = 0;

  private static final int ATTACH = 1;

  Effect[] mEffects;

  int[] mName;

  int[] mAssociation;

  long mTime;

  private static int[] mMax = new int[EffectType.LENGTH];

        mEffects         = new Effect[max];

        mName            = new int[max];

        mAssociation     = new int[max];

        }

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

        mCurrentDuration[i] = source.mCurrentDuration[i];

        mName[i]            = source.mName[i];

        mAssociation[i]     = source.mAssociation[i];

        }

      }

    }

      mCurrentDuration[j] = mCurrentDuration[j+1];

      mName[j]            = mName[j+1];

      mAssociation[j]     = mAssociation[j+1];

      }

    mEffects[mNumEffects] = null;

                       mEffects         = new Effect[max];

                       mName            = new int[max];

                       mAssociation     = new int[max];

                       }

                     mCreated = true;

                         mEffects[mNumEffects]    = job.effect;

                         mName[mNumEffects]       = job.effect.getName().ordinal();

                         mAssociation[mNumEffects]= job.effect.getAssociation();

                         mNumEffects++;

                         changed = true;

                           mEffects[j]         = mEffects[j-1];

                           mName[j]            = mName[j-1];

                           mAssociation[j]     = mAssociation[j-1];

                           }

                         mCurrentDuration[position] = 0;

                         mEffects[position]    = job.effect;

                         mName[position]       = job.effect.getName().ordinal();

                         mAssociation[position]= job.effect.getAssociation();

                         mNumEffects++;

                         changed = true;

    String mainVertHeader= version + ("#define NUM_VERTEX "   + ( numV>0 ? DistortedLibrary.getMax(EffectType.VERTEX  ) : 0 ) + "\n");

    String mainFragHeader= version + "\n";

    String enabledEffectV= VertexEffect.getGLSL();

    try

    int preProgramH = mPreProgram.getProgramHandle();

    EffectQueueVertex.getUniforms( preProgramH,2 );

    EffectQueueMatrix.getUniforms( preProgramH,2 );

    mPreColorH  = GLES30.glGetUniformLocation( preProgramH, "u_Color"  );

    mPreTextureH= GLES30.glGetUniformLocation( preProgramH, "u_Texture");

    }

  public boolean getRender()

    {

    }

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

    mPreProgram.useProgram();

    mesh.bindVertexAttribs(mPreProgram);

    EffectQueue[] queues = effects.getQueues();

    EffectQueueMatrix matrix = (EffectQueueMatrix)queues[0];

  private static int[] mNameH       = new int[MAIN_VARIANTS];

  private static int[] mUniformsH   = new int[MAIN_VARIANTS];

  private static int[] mAssociationH= new int[MAIN_VARIANTS];

  private static int[] mInflateH    = new int[MAIN_VARIANTS];

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

    mNumEffectsH[variant] = GLES30.glGetUniformLocation( mProgramH, "vNumEffects");

    mNameH[variant]       = GLES30.glGetUniformLocation( mProgramH, "vName");

    mUniformsH[variant]   = GLES30.glGetUniformLocation( mProgramH, "vUniforms");

    mInflateH[variant]    = GLES30.glGetUniformLocation( mProgramH, "u_Inflate");

    }

      {

      mCurrentDuration[i] += step;

      mAssociation[i] = mEffects[i].getAssociation();

      if( mEffects[i].compute(mUniforms, NUM_UNIFORMS*i, mCurrentDuration[i], step) )

        {

      {

      GLES30.glUniform1iv( mNameH[variant]       ,                 mNumEffects, mName       , 0);

      GLES30.glUniform1iv( mAssociationH[variant],                 mNumEffects, mAssociation, 0);

      GLES30.glUniform4fv( mUniformsH[variant]   ,(NUM_UNIFORMS/4)*mNumEffects, mUniforms   , 0);

      }

    }

    String mainVertHeader= mGLSL_VERSION + ("#define NUM_VERTEX "   + ( numV>0 ? getMax(EffectType.VERTEX  ) : 0 ) + "\n");

    String mainFragHeader= mGLSL_VERSION + ("#define NUM_FRAGMENT " + ( numF>0 ? getMax(EffectType.FRAGMENT) : 0 ) + "\n");

    String enabledEffectV= VertexEffect.getGLSL();

    String enabledEffectF= FragmentEffect.getGLSL();

    int mainProgramH = mMainProgram.getProgramHandle();

    EffectQueue.getUniforms(mainProgramH,0);

    mMainTextureH= GLES30.glGetUniformLocation( mainProgramH, "u_Texture");

    // BLIT PROGRAM ////////////////////////////////////

    String fullVertHeader= mGLSL_VERSION + ("#define NUM_VERTEX "   + ( numV>0 ? getMax(EffectType.VERTEX ) : 0 ) + "\n");

    String fullFragHeader= mGLSL_VERSION + ("#define NUM_FRAGMENT " +                                         0   + "\n");

    String enabledEffectV= VertexEffect.getAllGLSL();

    String enabledEffectF= "{}";

    int fullProgramH = mFullProgram.getProgramHandle();

    EffectQueue.getUniforms(fullProgramH,3);

    }

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

    String mainVertHeader= mGLSL_VERSION + ("#define NUM_VERTEX "   + ( numV>0 ? getMax(EffectType.VERTEX  ) : 0 ) + "\n") + ("#define OIT\n");

    String mainFragHeader= mGLSL_VERSION + ("#define NUM_FRAGMENT " + ( numF>0 ? getMax(EffectType.FRAGMENT) : 0 ) + "\n") + ("#define OIT\n");

    String enabledEffectV= VertexEffect.getGLSL();

    String enabledEffectF= FragmentEffect.getGLSL();

    int mainOITProgramH = mMainOITProgram.getProgramHandle();

    EffectQueue.getUniforms(mainOITProgramH,1);

    mMainOITTextureH    = GLES30.glGetUniformLocation( mainOITProgramH, "u_Texture");

    mMainOITSizeH       = GLES30.glGetUniformLocation( mainOITProgramH, "u_Size");

    mMainOITNumRecordsH = GLES30.glGetUniformLocation( mainOITProgramH, "u_numRecords");

    {

    if( mFullProgram!=null )

      {

      int num = mesh.getNumVertices();

      int tfo = mesh.getTFO();

      mesh.bindVertexAttribs(mFullProgram);

      mesh.computeQueue();

      mesh.sendQueue();

      GLES30.glBindBufferBase(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfo );

      GLES30.glBeginTransformFeedback( GLES30.GL_POINTS);

    GLES30.glUniform2ui(DistortedLibrary.mMainOITSizeH, surface.mWidth, surface.mHeight);

    GLES30.glUniform1ui(DistortedLibrary.mMainOITNumRecordsH, (int)(DistortedLibrary.mBufferSize*surface.mWidth*surface.mHeight) );

    mesh.bindVertexAttribs(DistortedLibrary.mMainOITProgram);

    float inflate     = mesh.getInflate();

    float distance    = surface.mDistance;

    if( mesh.getShowNormals() )

      {

      DistortedLibrary.mMainProgram.useProgram();

      EffectQueue.send(queues, distance, mipmap, projection, inflate, mesh, 0 );

      displayNormals(queues,mesh);

      }

      mMainProgram.useProgram();

      GLES30.glUniform1i(DistortedLibrary.mMainTextureH, 0);

      mesh.bindVertexAttribs(DistortedLibrary.mMainProgram);

      float inflate     = mesh.getInflate();

      float distance    = surface.mDistance;

import android.util.Log;

import org.distorted.library.effect.VertexEffect;

import org.distorted.library.effectqueue.EffectQueueVertex;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.InternalBuffer;

 */

public abstract class MeshBase

   {

   // sizes of attributes of an individual vertex.

   private static final int POS_DATA_SIZE= 3; // vertex coordinates: x,y,z

   private static final int NOR_DATA_SIZE= 3; // normal vector: x,y,z

   private static final int INF_DATA_SIZE= 3; // 'inflate' vector: x,y,z

   private static final int TEX_DATA_SIZE= 2; // texture coordinates: s,t

   static final int POS_ATTRIB   = 0;

   static final int NOR_ATTRIB   = POS_DATA_SIZE;

   static final int INF_ATTRIB   = POS_DATA_SIZE + NOR_DATA_SIZE;

   static final int TEX_ATTRIB   = 0;

   static final int VERT1_ATTRIBS= POS_DATA_SIZE + NOR_DATA_SIZE + INF_DATA_SIZE;  // number of attributes of a vertex (the part changed by preapply)

   static final int TRAN_ATTRIBS = POS_DATA_SIZE + NOR_DATA_SIZE + INF_DATA_SIZE;  // number of attributes of a transform feedback vertex

   private static final int BYTES_PER_FLOAT = 4;

   private static final int OFFSET_NOR = NOR_ATTRIB*BYTES_PER_FLOAT;

   private static final int OFFSET_INF = INF_ATTRIB*BYTES_PER_FLOAT;

   private static final int OFFSET_TEX = TEX_ATTRIB*BYTES_PER_FLOAT;

   private static final int TRAN_SIZE  = TRAN_ATTRIBS*BYTES_PER_FLOAT;

   private static final int VERT1_SIZE = VERT1_ATTRIBS*BYTES_PER_FLOAT;

   private InternalBuffer mVBO1, mVBO2, mTFO; // main vertex buffer and transform feedback buffer

   private int mNumVertices;

   private float[] mVertAttribs1;             // packed: PosX,PosY,PosZ, NorX,NorY,NorZ, InfX,InfY,InfZ

   private float mInflate;

   private boolean[] mNeedsAdjustment;

   private static class Component

     {

     mShowNormals= false;

     mInflate    = 0.0f;

     mComponent  = new ArrayList<>();

     mNeedsAdjustment = new boolean[1];

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

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

       mComponent.add(comp);

       }

     if( deep )

       {

       mNeedsAdjustment = new boolean[1];

     mTFO.invalidate();

     }

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

   int numComponents()

     mVertAttribs1= vert1Attribs;

     mVertAttribs2= vert2Attribs;

     mVBO1.invalidate();

     mVBO2.invalidate();

     {

     MeshBase mesh;

     Component comp;

     int origVertices = mNumVertices;

     // compute new numVertices; take care of Components

     if( origVertices>0 )

       {

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

       }

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

       mesh = meshes[i];

       numComponents = mesh.mComponent.size();

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

         {

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

         mComponent.add(comp);

         }

       }

     // allocate new attrib array

       android.util.Log.e("mesh", "join: origVertices: "+origVertices+" numVertices: "+mNumVertices);

       }

     mVertAttribs1 = newAttribs1;

     mVertAttribs2 = newAttribs2;

     return mNumVertices;

     }

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

/**

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

     GLES30.glVertexAttribPointer(program.mAttribute[2], INF_DATA_SIZE, GLES30.GL_FLOAT, false, VERT1_SIZE, OFFSET_INF);

     GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, index2 );

     GLES30.glVertexAttribPointer(program.mAttribute[3], TEX_DATA_SIZE, GLES30.GL_FLOAT, false, VERT2_SIZE, OFFSET_TEX);

     GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, 0);

     }

 *

 * This creates an association between a Component of this Mesh and a Vertex Effect.

 * One can set the association of an Effect and of a Component, and the Effect will only be active on

 *

 * The point: this way we can configure the system so that each Vertex Effect acts only on a certain

 * subset of a Mesh, thus potentially significantly reducing the number of render calls.

 */

  public void setEffectAssociation(int component, int association)

    {

      {

      }

    }

 *

 * @param deep If to be a deep or shallow copy of mVertAttribs1, i.e. the array holding vertices,

 *             normals and inflates (the rest, in particular the mVertAttribs2 containing texture

 */

   public abstract MeshBase copy(boolean deep);

   }

       attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[BACK]  + (1.0f-y) * mTexMappingH[BACK];

       }

     currVert++;

     }

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB  ] = mTexMappingX[TOP] +       x  * mTexMappingW[TOP];

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[TOP] + (0.5f-z) * mTexMappingH[TOP];

                   break;

       case SOUTH: row = curr.row+1;

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB  ] = mTexMappingX[BOTTOM] +       x  * mTexMappingW[BOTTOM];

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[BOTTOM] + (0.5f-z) * mTexMappingH[BOTTOM];

                   break;

       case WEST : row = (back  ? (curr.row+1):(curr.row));

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB  ] = mTexMappingX[LEFT] + (0.5f-z) * mTexMappingW[LEFT];

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[LEFT] + (1.0f-y) * mTexMappingH[LEFT];

                   break;

       case EAST : row = (back  ? (curr.row):(curr.row+1));

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB  ] = mTexMappingX[RIGHT] + (0.5f-z) * mTexMappingW[RIGHT];

                   attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = mTexMappingY[RIGHT] + (1.0f-y) * mTexMappingH[RIGHT];

                   break;

       }

     attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB  ] = attribs2[VERT2_ATTRIBS*(currVert-1) + TEX_ATTRIB  ];

     attribs2[VERT2_ATTRIBS*currVert + TEX_ATTRIB+1] = attribs2[VERT2_ATTRIBS*(currVert-1) + TEX_ATTRIB+1];

     currVert++;

     }

    attribs2[VERT2_ATTRIBS*index + TEX_ATTRIB  ] = x;

    attribs2[VERT2_ATTRIBS*index + TEX_ATTRIB+1] = 1.0f-y;

    }

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

     attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB  ] = x;

     attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB+1] = 1.0f-y;

     return vertex+1;

     }

       attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB  ] = attribs2[VERT2_ATTRIBS*(vertex-1) + TEX_ATTRIB  ];

       attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB+1] = attribs2[VERT2_ATTRIBS*(vertex-1) + TEX_ATTRIB+1];

       vertex++;

       }

      attribs2[VERT2_ATTRIBS*currentVert + TEX_ATTRIB  ] = attribs2[VERT2_ATTRIBS*(currentVert-1) + TEX_ATTRIB  ];

      attribs2[VERT2_ATTRIBS*currentVert + TEX_ATTRIB+1] = attribs2[VERT2_ATTRIBS*(currentVert-1) + TEX_ATTRIB+1];

      currentVert++;

      }

    attribs2[VERT2_ATTRIBS*currentVert + TEX_ATTRIB  ] = (float)texX;

    attribs2[VERT2_ATTRIBS*currentVert + TEX_ATTRIB+1] = (float)texY;

    currentVert++;

     attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB  ] = x;

     attribs2[VERT2_ATTRIBS*vertex + TEX_ATTRIB+1] = y;

     return vertex+1;

     }

      if( subline.startsWith(mAttributeStr))

        {

        for(nameBegin=subLen-1; nameBegin>mAttributeLen-2; nameBegin--)

          {

          currChar=subline.charAt(nameBegin);

    {

    String attribute, attrList="", uniform;

    String[] lines = shader.split("\n");

      {

        {

          {

          attrList += attribute;

          }

        }

        {

        mUniList += uniform;

        }

      }

      {

      String begin = code.substring(0,place-1);

      String end   = code.substring(place+length);

      return begin + effects + end;

      }

    else

in vec3 a_Inflate;                   // This vector describes the direction this vertex needs to go when we 'inflate' the whole mesh.

                                     // If the mesh is locally smooth, this is equal to the normal vector. Otherwise (on sharp edges) - no.

in vec2 a_TexCoordinate;             // Per-vertex texture coordinate.

                                     // to a vertex effect. An effect will only be active on a vertex iff (a_Association & vAssociation[effect]) != 0.

                                     // ( see VertexEffect.retSection() )

uniform vec4 vUniforms[3*NUM_VERTEX];// i-th effect is 3 consecutive vec4's: [3*i], [3*i+1], [3*i+2].

                                     // The first vec4 is the Interpolated values,

                                     // second vec4: first float - cache, next 3: Center, the third -  the Region.

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

// HELPER FUNCTIONS

#if NUM_VERTEX>0

  int effect=0;

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

    {

    effect+=3;

    }

#endif