Distorted Android

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

// Copyright 2016 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 android.opengl.Matrix;

import android.util.Log;

import org.distorted.library.effect.MatrixEffect;

import org.distorted.library.effect.VertexEffect;

import org.distorted.library.main.InternalBuffer;

import org.distorted.library.program.DistortedProgram;

import org.distorted.library.type.Static4D;

import java.io.DataOutputStream;

import java.io.IOException;

import java.io.DataInputStream;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

import java.util.ArrayList;

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

/**

 * Abstract class which represents a Mesh, ie an array of vertices (rendered as a TRIANGLE_STRIP).

 * <p>

 * If you want to render to a particular shape, extend from here, construct a float array

 * containing per-vertex attributes, and call back setAttribs().

 */

public abstract class MeshBase

   {

   private static final int ASSOC_UBO_BINDING  = 3;

   private static final int CENTER_UBO_BINDING = 4;

           static final int MAX_EFFECT_COMPONENTS= 100;

   // 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 TEX_DATA_SIZE= 2; // texture coordinates: s,t

   private static final int COM_DATA_SIZE= 1; // component number, a single float

   static final int POS_ATTRIB   = 0;

   static final int NOR_ATTRIB   = POS_DATA_SIZE;

   static final int TEX_ATTRIB   = 0;

   static final int COM_ATTRIB   = TEX_DATA_SIZE;

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

   static final int VERT2_ATTRIBS= TEX_DATA_SIZE + COM_DATA_SIZE;  // number of attributes of a vertex (the 'preapply invariant' part)

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

   private static final int BYTES_PER_FLOAT = 4;

   private static final int OFFSET_POS = POS_ATTRIB*BYTES_PER_FLOAT;

   private static final int OFFSET_NOR = NOR_ATTRIB*BYTES_PER_FLOAT;

   private static final int OFFSET_TEX = TEX_ATTRIB*BYTES_PER_FLOAT;

   private static final int OFFSET_COM = COM_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 static final int VERT2_SIZE = VERT2_ATTRIBS*BYTES_PER_FLOAT;

   private boolean mShowNormals;              // when rendering this mesh, draw normal vectors?

   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

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

   private float mInflate;

   private UniformBlockAssociation mUBA;

   private UniformBlockCenter mUBC;

   DeferredJobs.JobNode[] mJobNode;

   private static final int TEX_COMP_SIZE = 5; // 5 four-byte entities inside the component

   private static class TexComponent

     {

     private int mEndIndex;

     private Static4D mTextureMap;

     TexComponent(int end)

       {

       mEndIndex  = end;

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

       }

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

       }

     void setMap(Static4D map)

       {

       mTextureMap.set(map.get0(),map.get1(),map.get2(),map.get3());

       }

     }

   private ArrayList<TexComponent> mTexComponent;

   private ArrayList<Integer> mEffComponent;

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

   MeshBase()

     {

     mShowNormals  = false;

     mInflate      = 0.0f;

     mTexComponent = new ArrayList<>();

     mEffComponent = new ArrayList<>();

     mJobNode = new DeferredJobs.JobNode[1];

     mUBA = new UniformBlockAssociation();

     mUBC = new UniformBlockCenter();

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

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

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

     }

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

// copy constructor

   MeshBase(MeshBase original, boolean deep)

     {

     mShowNormals= original.mShowNormals;

     mInflate    = original.mInflate;

     mNumVertices= original.mNumVertices;

     mUBA = new UniformBlockAssociation(original.mUBA);

     mUBC = new UniformBlockCenter(original.mUBC);

     if( deep )

       {

       mJobNode = new DeferredJobs.JobNode[1];

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

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

       }

     else

       {

       mJobNode      = original.mJobNode;

       mVBO1         = original.mVBO1;

       mVertAttribs1 = original.mVertAttribs1;

       shallowCopy(original);

       }

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

     }

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

   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 texComSize = original.mTexComponent.size();

     mTexComponent = new ArrayList<>();

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

       {

       TexComponent comp = new TexComponent(original.mTexComponent.get(i));

       mTexComponent.add(comp);

       }

     mEffComponent = new ArrayList<>();

     mEffComponent.addAll(original.mEffComponent);

     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 mergeTexComponentsNow()

     {

     int num = mTexComponent.size();

     if( num>1 )

       {

       mTexComponent.clear();

       mTexComponent.add(new TexComponent(mNumVertices-1));

       mVBO2.invalidate();

       }

     }

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

   void mergeEffComponentsNow()

     {

     int num = mEffComponent.size();

     if( num>1 )

       {

       mEffComponent.clear();

       mEffComponent.add(mNumVertices-1);

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

         {

         mVertAttribs2[VERT2_ATTRIBS*index+COM_ATTRIB] = 0;

         }

       mVBO2.invalidate();

       }

     }

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

   void applyMatrix(MatrixEffect effect, int andAssoc, int equAssoc)

     {

     float[] matrixP  = new float[16];

     float[] matrixV  = new float[16];

     float[] uniforms = new float[7];

     int start, end=-1, numComp = mEffComponent.size();

     Matrix.setIdentityM(matrixP,0);

     Matrix.setIdentityM(matrixV,0);

     effect.compute(uniforms,0,0,0);

     effect.apply(matrixP, matrixV, uniforms, 0);

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

       {

       start = end+1;

       end   = mEffComponent.get(comp);

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

         {

         applyMatrixToComponent(matrixP, matrixV, start, end);

         }

       }

     mVBO1.invalidate();

     }

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

   private void applyMatrixToComponent(float[] matrixP, float[] matrixV, int start, int end)

     {

     float x,y,z;

     for(int index=start*VERT1_ATTRIBS; index<=end*VERT1_ATTRIBS; index+=VERT1_ATTRIBS )

       {

       x = mVertAttribs1[index+POS_ATTRIB  ];

       y = mVertAttribs1[index+POS_ATTRIB+1];

       z = mVertAttribs1[index+POS_ATTRIB+2];

       mVertAttribs1[index+POS_ATTRIB  ] = matrixP[0]*x + matrixP[4]*y + matrixP[ 8]*z + matrixP[12];

       mVertAttribs1[index+POS_ATTRIB+1] = matrixP[1]*x + matrixP[5]*y + matrixP[ 9]*z + matrixP[13];

       mVertAttribs1[index+POS_ATTRIB+2] = matrixP[2]*x + matrixP[6]*y + matrixP[10]*z + matrixP[14];

       x = mVertAttribs1[index+NOR_ATTRIB  ];

       y = mVertAttribs1[index+NOR_ATTRIB+1];

       z = mVertAttribs1[index+NOR_ATTRIB+2];

       mVertAttribs1[index+NOR_ATTRIB  ] = matrixV[0]*x + matrixV[4]*y + matrixV[ 8]*z;

       mVertAttribs1[index+NOR_ATTRIB+1] = matrixV[1]*x + matrixV[5]*y + matrixV[ 9]*z;

       mVertAttribs1[index+NOR_ATTRIB+2] = matrixV[2]*x + matrixV[6]*y + matrixV[10]*z;

       x = mVertAttribs1[index+NOR_ATTRIB  ];

       y = mVertAttribs1[index+NOR_ATTRIB+1];

       z = mVertAttribs1[index+NOR_ATTRIB+2];

       float len1 = (float)Math.sqrt(x*x + y*y + z*z);

       if( len1>0.0f )

         {

         mVertAttribs1[index+NOR_ATTRIB  ] /= len1;

         mVertAttribs1[index+NOR_ATTRIB+1] /= len1;

         mVertAttribs1[index+NOR_ATTRIB+2] /= len1;

         }

       }

     }

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

   void setEffectAssociationNow(int component, int andAssociation, int equAssociation)

     {

     mUBA.setEffectAssociationNow(component, andAssociation, equAssociation);

     }

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

   void setComponentCenterNow(int component, float x, float y, float z)

     {

     mUBC.setEffectCenterNow(component, x, y, z);

     }

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

// when a derived class is done computing its mesh, it has to call this method.

   void setAttribs(float[] vert1Attribs, float[] vert2Attribs)

     {

     mNumVertices = vert1Attribs.length/VERT1_ATTRIBS;

     mVertAttribs1= vert1Attribs;

     mVertAttribs2= vert2Attribs;

     mTexComponent.add(new TexComponent(mNumVertices-1));

     mEffComponent.add(mNumVertices-1);

     mVBO1.invalidate();

     mVBO2.invalidate();

     }

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

   void joinAttribs(MeshBase[] meshes)

     {

     MeshBase mesh;

     TexComponent comp;

     int numMeshes = meshes.length;

     int numVertices,origVertices = mNumVertices;

     int origTexComponents,numTexComponents;

     int origEffComponents=0,numEffComponents;

     if( origVertices>0 )

       {

       origTexComponents = mTexComponent.size();

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

       mTexComponent.get(origTexComponents-1).mEndIndex = mNumVertices-1;

       origEffComponents = mEffComponent.size();

       mEffComponent.set(origEffComponents-1,mNumVertices-1);

       }

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

       {

       mesh = meshes[i];

       numTexComponents = mesh.mTexComponent.size();

       numEffComponents = mesh.mEffComponent.size();

       numVertices = mesh.mNumVertices;

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

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

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

         {

         comp = new TexComponent(mesh.mTexComponent.get(j));

         comp.mEndIndex += (extraVerticesBefore+mNumVertices);

         if( j==numTexComponents-1) comp.mEndIndex += extraVerticesAfter;

         mTexComponent.add(comp);

         }

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

         {

         int index = mesh.mEffComponent.get(j);

         index += (extraVerticesBefore+mNumVertices);

         if( j==numEffComponents-1 ) index += extraVerticesAfter;

         mEffComponent.add(index);

         if( origEffComponents<MAX_EFFECT_COMPONENTS )

           {

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

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

           origEffComponents++;

           }

         }

       mNumVertices += (extraVerticesBefore+numVertices+extraVerticesAfter);

       }

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

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

     numVertices = origVertices;

     if( origVertices>0 )

       {

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

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

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

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

       origVertices++;

       if( numVertices%2==1 )

         {

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

         origVertices++;

         }

       }

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

       {

       mesh = meshes[i];

       numVertices = mesh.mNumVertices;

       if( origVertices>0 )

         {

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

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

         origVertices++;

         }

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

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

       origVertices+=numVertices;

       if( i<numMeshes-1 )

         {

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

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

         origVertices++;

         if( numVertices%2==1 )

           {

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

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

           origVertices++;

           }

         }

       }

     if( origVertices!=mNumVertices )

       {

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

       }

     int endIndex, index=0, numEffComp = mEffComponent.size();

     for(int component=0; component<numEffComp; component++)

       {

       endIndex = mEffComponent.get(component);

       for( ; index<=endIndex; index++) newAttribs2[VERT2_ATTRIBS*index+COM_ATTRIB] = component;

       }

     mVertAttribs1 = newAttribs1;

     mVertAttribs2 = newAttribs2;

     mVBO1.invalidate();

     mVBO2.invalidate();

     }

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

// called from MeshJoined

   void join(MeshBase[] meshes)

     {

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

     {

     int num_comp = mTexComponent.size();

     int num_maps = maps.length;

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

     int vertex = startComponent>0 ? mTexComponent.get(startComponent-1).mEndIndex+1 : 0;

     Static4D newMap, oldMap;

     TexComponent comp;

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

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

       {

       newMap = maps[i];

       comp = mTexComponent.get(i+startComponent);

       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 getMaxEffComponents()

     {

     return MAX_EFFECT_COMPONENTS;

     }

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

/**

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

 *

 * @y.exclude

 */

   public void copyTransformToVertex()

     {

     ByteBuffer buffer = (ByteBuffer)GLES30.glMapBufferRange( GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, 0,

                                                              TRAN_SIZE*mNumVertices, GLES30.GL_MAP_READ_BIT);

     if( buffer!=null )

       {

       FloatBuffer feedback = buffer.order(ByteOrder.nativeOrder()).asFloatBuffer();

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

       mVBO1.updateFloat(mVertAttribs1);

       }

     else

       {

       int error = GLES30.glGetError();

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

       }

     GLES30.glUnmapBuffer(GLES30.GL_TRANSFORM_FEEDBACK);

     }

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

/**

 * 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 printPos()

     {

     StringBuilder sb = new StringBuilder();

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

       }

     Log.d("mesh", sb.toString());

     }

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

/**

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

 *

 * @y.exclude

 */

   public void printCom()

     {

     StringBuilder sb = new StringBuilder();

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

       {

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

       sb.append(' ');

       }

     Log.d("mesh", sb.toString());

     }

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

/**

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

 *

 * @y.exclude

 */

   public void printTex()

     {

     int vert=0;

     int num = numTexComponents();

     StringBuilder sb = new StringBuilder();

     sb.append("tex components: ").append(num);

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

       {

       int end = mTexComponent.get(i).mEndIndex;

       sb.append("\n");

       for( ; vert<=end; vert++)

         {

         sb.append(' ');

         sb.append('(');

         sb.append(mVertAttribs2[VERT2_ATTRIBS*vert+TEX_ATTRIB]);

         sb.append(',');

         sb.append(mVertAttribs2[VERT2_ATTRIBS*vert+TEX_ATTRIB+1]);

         sb.append(')');

         }

       }

     Log.d("mesh", sb.toString());

     }

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

/**

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

 *

 * @y.exclude

 */

   public int getTFO()

     {

     return mTFO.createImmediatelyFloat(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

 */

   public int getNumVertices()

     {

     return mNumVertices;

     }

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

/**

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

 *

 * @y.exclude

 */

   public void send(int programH)

     {

     int indexA = mUBA.getIndex();

     GLES30.glBindBufferBase(GLES30.GL_UNIFORM_BUFFER, ASSOC_UBO_BINDING, indexA);

     GLES30.glUniformBlockBinding(programH, ASSOC_UBO_BINDING, indexA);

     int indexC = mUBC.getIndex();

     GLES30.glBindBufferBase(GLES30.GL_UNIFORM_BUFFER, CENTER_UBO_BINDING, indexC);

     GLES30.glUniformBlockBinding(programH, CENTER_UBO_BINDING, indexC);

     }

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

/**

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

 *

 * @y.exclude

 */

   public void bindVertexAttribs(DistortedProgram program)

     {

     if( mJobNode[0]!=null )

       {

       mJobNode[0].execute();  // this will set itself to null

/*

       try

         {

         String name = "/sdcard/"+mNumVertices+".dmesh";

         DataOutputStream dos = new DataOutputStream(new java.io.FileOutputStream(name));

         write(dos);

         android.util.Log.e("mesh", "file written: "+name);

         }

       catch(java.io.FileNotFoundException ex)

         {

         android.util.Log.e("mesh", "file not found exception: "+ex.toString());

         }

 */

       }

     int index1 = mVBO1.createImmediatelyFloat(mNumVertices*VERT1_SIZE, mVertAttribs1);

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

     GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, index1 );

     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.glBindBuffer(GLES30.GL_ARRAY_BUFFER, index2 );

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

     GLES30.glVertexAttribPointer(program.mAttribute[3], COM_DATA_SIZE, GLES30.GL_FLOAT, false, VERT2_SIZE, OFFSET_COM);

     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 bindTransformAttribs(DistortedProgram program)

     {

     int index = mTFO.createImmediatelyFloat(mNumVertices*TRAN_SIZE, null);

     GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, index );

     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;

     }

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

// Return the number of bytes read.

   int read(DataInputStream stream)

     {

     byte[] buffer = new byte[BYTES_PER_FLOAT*4];

     int version, numEff, numTex;

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

     // read version, number of vertices, number of tex components, number of effect components

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

     try

       {

       stream.read(buffer);

       ByteBuffer byteBuf = ByteBuffer.wrap(buffer);

       version = byteBuf.getInt(0);

       if( version==1 || version==2 )

         {

         mNumVertices= byteBuf.getInt(4);

         numTex      = byteBuf.getInt(8);

         numEff      = byteBuf.getInt(12);

         }

       else

         {

         android.util.Log.e("mesh", "Error: unknown mesh file version "+String.format("0x%08X", version));

         return 0;

         }

       }

     catch(IOException e)

       {

       android.util.Log.e("mesh", "IOException1 trying to read file: "+e.toString());

       return 0;

       }

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

     // read contents of all texture and effect components

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

     if( mNumVertices>0 && numEff>0 && numTex>0 )

       {

       int size = numEff+TEX_COMP_SIZE*numTex;

       float[] tmp = new float[size];

       mVertAttribs1 = new float[VERT1_ATTRIBS*mNumVertices];

       mVertAttribs2 = new float[VERT2_ATTRIBS*mNumVertices];

       // version 1 had extra 3 floats (the 'inflate' vector) in its vert1 array

       int vert1InFile = version==2 ? VERT1_ATTRIBS : VERT1_ATTRIBS+3;