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.main.InternalBuffer;

import java.nio.ByteOrder;

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

   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;

   static final int TEX_ATTRIB   = POS_DATA_SIZE + NOR_DATA_SIZE + INF_DATA_SIZE;

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

   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 VERT_SIZE  = VERT_ATTRIBS*BYTES_PER_FLOAT;

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

     {

     private int mEndIndex;

     private float[] mTextureMap;

     Component()

       {

       mTextureMap = new float[8];

       mTextureMap[ 0] = 0.0f;  // LLX

       mTextureMap[ 1] = 0.0f;  // LLY

       mTextureMap[ 2] = 0.0f;  // ULX

       mTextureMap[ 3] = 1.0f;  // ULY

       mTextureMap[ 4] = 1.0f;  // URX

       mTextureMap[ 5] = 1.0f;  // URY

       mTextureMap[ 6] = 1.0f;  // LRX

       mTextureMap[ 7] = 0.0f;  // LRY

       }

     Component(Component original)

       {

       mEndIndex = original.mEndIndex;

       mTextureMap = new float[8];

       System.arraycopy(original.mTextureMap,0,mTextureMap,0,8);

       }

     }

   private ArrayList<Component> mComponent;

     mComponent = new ArrayList<>();

     mComponent.add(new Component());

     mVBO = new InternalBuffer(GLES31.GL_ARRAY_BUFFER             , GLES31.GL_STATIC_READ);

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

     }

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

// copy constructor

   MeshBase(MeshBase original)

     {

     mShowNormals = original.mShowNormals;

     mInflate     = original.mInflate;

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

       }

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

     System.arraycopy(original.mVertAttribs,0,mVertAttribs,0,original.mNumVertices*VERT_ATTRIBS);

     setAttribs(mVertAttribs);

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

     attribs.put(vertexAttribs).position(0);

     mTFO.setData(mNumVertices*TRAN_SIZE, null   );

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

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

 *

 * @y.exclude

 */

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

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

 *

 * @y.exclude

 */

/**

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

 *

 * @y.exclude

 */

     GLES31.glVertexAttribPointer(program.mAttribute[1], NOR_DATA_SIZE, GLES31.GL_FLOAT, false, VERT_SIZE, OFFSET_NOR);

     GLES31.glVertexAttribPointer(program.mAttribute[2], INF_DATA_SIZE, GLES31.GL_FLOAT, false, VERT_SIZE, OFFSET_INF);

     GLES31.glVertexAttribPointer(program.mAttribute[3], TEX_DATA_SIZE, GLES31.GL_FLOAT, false, VERT_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)

     {

     GLES31.glBindBuffer(GLES31.GL_ARRAY_BUFFER, mTFO.mIndex[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()

     {

     mVBO.markForDeletion();

     mTFO.markForDeletion();

     }

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

/**

 * contain any Dynamics, they will be evaluated at 0.

 * Please note that calling this once with the complete list of Effects will be much faster than

 * calling it repeatedly with one Effect at a time, as we have to reallocate the array of vertices

 * each time.

 */

   public void apply(MatrixEffect[] effects)

     {

     float[] tmp;

     float[] array = new float[4];

     float x,y,z;

     int numEffects = 0;

     for(MatrixEffect eff: effects)

         eff.compute(array,0,0,0);

         eff.apply(matrix[numEffects], array, 0);

         numEffects++;

       }

       {

       for(int mat=0; mat<numEffects; mat++)

         {

         tmp = matrix[mat];

         x = mVertAttribs[index+POS_ATTRIB  ];

         y = mVertAttribs[index+POS_ATTRIB+1];

         z = mVertAttribs[index+POS_ATTRIB+2];

         mVertAttribs[index+POS_ATTRIB  ] = tmp[0]*x + tmp[4]*y + tmp[ 8]*z + tmp[12];

         mVertAttribs[index+POS_ATTRIB+1] = tmp[1]*x + tmp[5]*y + tmp[ 9]*z + tmp[13];

         mVertAttribs[index+POS_ATTRIB+2] = tmp[2]*x + tmp[6]*y + tmp[10]*z + tmp[14];

         x = mVertAttribs[index+NOR_ATTRIB  ];

         y = mVertAttribs[index+NOR_ATTRIB+1];

         z = mVertAttribs[index+NOR_ATTRIB+2];

         mVertAttribs[index+NOR_ATTRIB  ] = tmp[0]*x + tmp[4]*y + tmp[ 8]*z;

         mVertAttribs[index+NOR_ATTRIB+1] = tmp[1]*x + tmp[5]*y + tmp[ 9]*z;

         mVertAttribs[index+NOR_ATTRIB+2] = tmp[2]*x + tmp[6]*y + tmp[10]*z;

         x = mVertAttribs[index+INF_ATTRIB  ];

         y = mVertAttribs[index+INF_ATTRIB+1];

         z = mVertAttribs[index+INF_ATTRIB+2];

         mVertAttribs[index+INF_ATTRIB  ] = tmp[0]*x + tmp[4]*y + tmp[ 8]*z;

         mVertAttribs[index+INF_ATTRIB+1] = tmp[1]*x + tmp[5]*y + tmp[ 9]*z;

         mVertAttribs[index+INF_ATTRIB+2] = tmp[2]*x + tmp[6]*y + tmp[10]*z;

         }

       }

     FloatBuffer attribs = ByteBuffer.allocateDirect(mNumVertices*VERT_SIZE).order(ByteOrder.nativeOrder()).asFloatBuffer();

     attribs.put(mVertAttribs).position(0);

     mVBO.setData(mNumVertices*VERT_SIZE, attribs);

     mTFO.setData(mNumVertices*TRAN_SIZE, null   );

     }

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

/**

 * Join a list of Meshes into this one.

 * <p>

 * Please note that calling this once with the complete list of Meshes will be much faster than

 * calling it repeatedly with one Mesh at a time, as we have to reallocate the array of vertices

 * each time.

 */

   public void join(MeshBase[] meshes)

     {