Distorted Android

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

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

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

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

//                                                                                               //

// 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                             //

import org.distorted.library.effectqueue.EffectQueueVertex;

import org.distorted.library.main.DistortedLibrary;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

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

   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

   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;

   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 VERT2_SIZE = VERT2_ATTRIBS*BYTES_PER_FLOAT;

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

   private float[] mVertAttribs2;             // packed: TexS,TexT

     private int mEndIndex;

       mTextureMap= new Static4D(0,0,1,1);

     Component(Component original)

       {

       mEndIndex = original.mEndIndex;

       float x = original.mTextureMap.get0();

       float y = original.mTextureMap.get1();

       float z = original.mTextureMap.get2();

       float w = original.mTextureMap.get3();

       mTextureMap = new Static4D(x,y,z,w);

     }

   private ArrayList<Component> mComponent;

     mInflate    = 0.0f;

     mComponent  = new ArrayList<>();

     mNeedsAdjustment = new boolean[1];

     mNeedsAdjustment[0] = false;

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

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

// copy constructor

     mInflate         = original.mInflate;

     int size = original.mComponent.size();

     mComponent = new ArrayList<>();

       {

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

       mComponent.add(comp);

       }

       {

       mNeedsAdjustment = new boolean[1];

       mNeedsAdjustment[0] = original.mNeedsAdjustment[0];

       mVertAttribs1= new float[mNumVertices*VERT1_ATTRIBS];

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

       mVBO1.invalidate();

       }

     else

       {

       mNeedsAdjustment = original.mNeedsAdjustment;

       mVBO1            = original.mVBO1;

       mVertAttribs1    = original.mVertAttribs1;

       }

     mVertAttribs2= new float[mNumVertices*VERT2_ATTRIBS];

     mVBO2.invalidate();

     mTFO = new InternalBuffer(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, GLES30.GL_STATIC_READ);

   int numComponents()

     {

     return mComponent.size();

     }

     mVertAttribs1= vert1Attribs;

     mVertAttribs2= vert2Attribs;

     mVBO2.invalidate();

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

     Component comp;

       {

       mesh = meshes[i];

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

         comp.mEndIndex += mNumVertices;

         mComponent.add(comp);

         }

         {

         if( numMeshes>1 )

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

         else

            mNumVertices +=  numVertices;

         }

       else if( i==numMeshes-1 ) mNumVertices += (numVertices+1);

       else                      mNumVertices += (numVertices%2==1 ? numVertices+3 : numVertices+2);

     // allocate new attrib array

     float[] newAttribs2 = new float[VERT2_ATTRIBS*mNumVertices];

     if( origVertices>0 )

       {

       System.arraycopy(mVertAttribs2,                              0, newAttribs2,                         0, VERT2_ATTRIBS*numVertices);

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

       System.arraycopy(mVertAttribs2, VERT2_ATTRIBS*(origVertices-1), newAttribs2, VERT2_ATTRIBS*origVertices, VERT2_ATTRIBS    );

         System.arraycopy(mVertAttribs2, VERT2_ATTRIBS*(origVertices-1), newAttribs2, VERT2_ATTRIBS*origVertices, VERT2_ATTRIBS);

         }

       }

       mesh = meshes[i];

         {

         System.arraycopy(mesh.mVertAttribs2, 0, newAttribs2, VERT2_ATTRIBS*origVertices, VERT2_ATTRIBS    );

         }

       System.arraycopy(mesh.mVertAttribs2, 0, newAttribs2, VERT2_ATTRIBS*origVertices, VERT2_ATTRIBS*numVertices);

         System.arraycopy(mesh.mVertAttribs2, VERT2_ATTRIBS*(numVertices-1), newAttribs2, VERT2_ATTRIBS*origVertices, VERT2_ATTRIBS);

           System.arraycopy(mesh.mVertAttribs2, VERT2_ATTRIBS*(numVertices-1), newAttribs2, VERT2_ATTRIBS*origVertices, VERT2_ATTRIBS);

           }

         }

       }

     if( origVertices!=mNumVertices )

       {

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

       }

     mVertAttribs2 = newAttribs2;

     mVBO2.invalidate();

/**

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

 *

 * @y.exclude

 */

   public void copyTransformToVertex()

     {

                                                              TRAN_SIZE*mNumVertices, GLES30.GL_MAP_READ_BIT);

       {

       feedback.get(mVertAttribs1,0,VERT1_ATTRIBS*mNumVertices);

       mVBO1.update(mVertAttribs1);

     else

       {

       Log.e("mesh", "failed to map tf buffer, error="+error);

     int numComp = mComponent.size();

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

       {

       mComponent.get(i).mQueue.removeAll(false);

       }

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

/**

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

 *

 * @y.exclude

 */

   public void computeQueue()

     {

     int numComp = mComponent.size();

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

       {

       mComponent.get(i).mQueue.compute(1);

       }

     }

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

/**

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

 *

 * @y.exclude

 */

   public void sendQueue()

     {

     int numComp = mComponent.size();

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

       {

     }

/**

 *

 * @y.exclude

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

/**

 *

 * @y.exclude

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

 *

 * @y.exclude

 */

       }

     int index2 = mVBO2.createImmediately(mNumVertices*VERT2_SIZE, mVertAttribs2);

     GLES30.glVertexAttribPointer(program.mAttribute[0], POS_DATA_SIZE, GLES30.GL_FLOAT, false, VERT1_SIZE, OFFSET_POS);

     GLES30.glVertexAttribPointer(program.mAttribute[1], NOR_DATA_SIZE, GLES30.GL_FLOAT, false, VERT1_SIZE, OFFSET_NOR);

     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);

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

/**

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

 *

 * @y.exclude

 */

   public void bindTransformAttribs(DistortedProgram program)

     {

     GLES30.glVertexAttribPointer(program.mAttribute[0], POS_DATA_SIZE, GLES30.GL_FLOAT, false, 0, 0);

     GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, 0);

/**

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

 *

 * @y.exclude

 */

   public void setInflate(float inflate)

     {

     mInflate = inflate;

     }

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

/**

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

 *

 * @y.exclude

 */

   public float getInflate()

     {

     return mInflate;

     }

// PUBLIC API

/**

 * When rendering this Mesh, do we want to render the Normal vectors as well?

 * Will work only on OpenGL ES >= 3.0 devices.

 * @param show Controls if we render the Normal vectors or not.

 */

   public void setShowNormals(boolean show)

     {

/**

 * When rendering this mesh, should we also draw the normal vectors?

 *

 * @return <i>true</i> if we do render normal vectors

 */

   public boolean getShowNormals()

     {

     return mShowNormals;

     }

/**

 * Release all internal resources.

 */

   public void markForDeletion()

     {

     mVertAttribs2 = null;

     mVBO2.markForDeletion();

     }

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

/**

 * lazily executed only when the Mesh is used for rendering for the first time.

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

/**

 * For example maps[0] = new Static4D( 0.0, 0.5, 0.5, 0.5 ) sets the 0th component texture map to the

 * Probably the most common user case would be sending as many maps as there are components in this

 * Mesh. One can also send less, or more (the extraneous ones will be ignored) and set some of them

 * to null (those will be ignored as well). So if there are 5 components, and we want to set the map

 * of the 2nd and 4rd one, call this with

 * maps = new Static4D[4]

 * maps[0] = null

 * maps[1] = the map for the 2nd component

 * maps[2] = null

 * maps[3] = the map for the 4th component

 *

 * A map's width and height have to be non-zero (but can be negative!)

 * @param maps List of texture maps to apply to the texture's components.

     int num_maps = maps.length;

       if( newMap!=null )

         newH = newMap.get3();

           ratW = newW/oldMap.get2();

           ratH = newH/oldMap.get3();

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

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

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

           comp.setMap(newMap);

       vertex= comp.mEndIndex+1;

/**

 * Return the texture map of one of the components.

 *

 * @param component The component number whose texture map we want to retrieve.

 */

   public Static4D getTextureMap(int component)

     {

     return (component>=0 && component<mComponent.size()) ? mComponent.get(component).mTextureMap : null;

     }

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

/**

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

 * vertices of Components such that (effect assoc) & (component assoc) != 0. (see VertexEffect.retSection() )

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

    int num = mComponent.size();

      {

      end = end*VERT2_ATTRIBS + ASS_ATTRIB;

      mVBO2.invalidate();

      }

    }

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

/**

 *

 * @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

 *             coordinates and effect assocciations, is always deep copied)