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.GLES31;

import android.opengl.Matrix;

import org.distorted.library.effect.MatrixEffect;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.InternalBuffer;

import org.distorted.library.program.DistortedProgram;

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

   {

   // 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   = POS_DATA_SIZE + NOR_DATA_SIZE + INF_DATA_SIZE;

   static final int VERT_ATTRIBS = POS_DATA_SIZE + NOR_DATA_SIZE + INF_DATA_SIZE + TEX_DATA_SIZE;  // number of attributes of a 'normal' vertex

   static final int TRAN_ATTRIBS = POS_DATA_SIZE + POS_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_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 VERT_SIZE  = VERT_ATTRIBS*BYTES_PER_FLOAT;

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

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

   private int mNumVertices;

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

   private float mInflate;

   private float mBoundingX, mBoundingY, mBoundingZ;

   private float mStretchX, mStretchY, mStretchZ;

   private class Component

     {

     private int mEndIndex;

     private float[] mTextureMap;

     Component(int end)

       {

       mEndIndex = end;

       mTextureMap    = new float[4];

       mTextureMap[0] = 0.0f;  // LowerLeft_X

       mTextureMap[1] = 0.0f;  // LowerLeft_Y

       mTextureMap[2] = 1.0f;  // Width

       mTextureMap[3] = 1.0f;  // Height

       }

     Component(Component original)

       {

       mEndIndex = original.mEndIndex;

       mTextureMap = new float[4];

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

       }

     void setMap(float[] newMap)

       {

       mTextureMap = newMap;

       }

     }

   private ArrayList<Component> mComponent;

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

   MeshBase(float bx, float by, float bz)

     {

     mBoundingX = bx/2;

     mBoundingY = by/2;

     mBoundingZ = bz/2;

     mStretchX = 1.0f;

     mStretchY = 1.0f;

     mStretchZ = 1.0f;

     mShowNormals = false;

     mInflate     = 0.0f;

     mComponent   = new ArrayList<>();

     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)

     {

     mBoundingX = original.mBoundingX;

     mBoundingY = original.mBoundingY;

     mBoundingZ = original.mBoundingZ;

     mStretchX = original.mStretchX;

     mStretchY = original.mStretchY;

     mStretchZ = original.mStretchZ;

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

       }

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

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

     }

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

// change mVertAttribs from index 'begin' to index 'end' (inclusive) to the new Texture Map.

// x varies from -mBoundingX to +mBoundingX; y accordingly.

   private void changeTextureMap( float[] newMap, float[] oldMap, int begin, int end)

     {

     }

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

   int numComponents()

     {

     return mComponent.size();

     }

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

   void setBounding(float bx, float by, float bz)

     {

     mBoundingX = bx/2;

     mBoundingY = by/2;

     mBoundingZ = bz/2;

     }

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

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

   void setAttribs(float[] vertexAttribs)

     {

     mNumVertices = vertexAttribs.length/VERT_ATTRIBS;

     mVertAttribs = vertexAttribs;

     mComponent.add(new Component(mNumVertices));

     mVBO.invalidate();

     mTFO.invalidate();

     }

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

// called from MeshJoined

   void join(MeshBase[] meshes)

     {

     MeshBase mesh;

     Component comp;

     int com, num, len = meshes.length;

     int origVertices = mNumVertices;

     // compute new numVertices; take care of Components

     if( origVertices>0 )

       {

       com = mComponent.size();

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

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

       }

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

       {

       mesh = meshes[i];

       com = mesh.mComponent.size();

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

         {

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

         comp.mEndIndex += mNumVertices;

         mComponent.add(comp);

         }

       num = mesh.mNumVertices;

       if( mNumVertices==0 ) mNumVertices += (num%2==1 ? num+2 : num+1);

       else if( i==len-1 )   mNumVertices += (num+1);

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

       }

     // allocate new attrib array

     float[] newAttribs = new float[VERT_ATTRIBS*mNumVertices];

     num = origVertices;

     if( origVertices>0 )

       {

       System.arraycopy(mVertAttribs,                             0, newAttribs,                         0, VERT_ATTRIBS*num);

       System.arraycopy(mVertAttribs, VERT_ATTRIBS*(origVertices-1), newAttribs, VERT_ATTRIBS*origVertices, VERT_ATTRIBS    );

       origVertices++;

       if( num%2==1 )

         {

         System.arraycopy(mVertAttribs, VERT_ATTRIBS*(origVertices-1), newAttribs, VERT_ATTRIBS*origVertices, VERT_ATTRIBS);

         origVertices++;

         }

       }

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

       {

       mesh = meshes[i];

       num = mesh.mNumVertices;

       if( origVertices>0 )

         {

         System.arraycopy(mesh.mVertAttribs, 0, newAttribs, VERT_ATTRIBS*origVertices, VERT_ATTRIBS    );

         origVertices++;

         }

       System.arraycopy(mesh.mVertAttribs, 0, newAttribs, VERT_ATTRIBS*origVertices, VERT_ATTRIBS*num);

       origVertices+=num;

       if( i<len-1 )

         {

         System.arraycopy(mesh.mVertAttribs, VERT_ATTRIBS*(num-1), newAttribs, VERT_ATTRIBS*origVertices, VERT_ATTRIBS);

         origVertices++;

         if( num%2==1 )

           {

           System.arraycopy(mesh.mVertAttribs, VERT_ATTRIBS*(num-1), newAttribs, VERT_ATTRIBS*origVertices, VERT_ATTRIBS);

           origVertices++;

           }

         }

       }

     if( origVertices!=mNumVertices )

       {

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

       }

     mVertAttribs = newAttribs;

     mVBO.invalidate();

     }

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

/**

 * 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.mIndex[0];

     }

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

/**

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

     {

     mVBO.createImmediately(mNumVertices*VERT_SIZE, mVertAttribs);

     GLES31.glBindBuffer(GLES31.GL_ARRAY_BUFFER, mVBO.mIndex[0] );

     GLES31.glVertexAttribPointer(program.mAttribute[0], POS_DATA_SIZE, GLES31.GL_FLOAT, false, VERT_SIZE, OFFSET_POS);

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

     GLES31.glBindBuffer(GLES31.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)

     {

     mTFO.createImmediately(mNumVertices*TRAN_SIZE, null);

     GLES31.glBindBuffer(GLES31.GL_ARRAY_BUFFER, mTFO.mIndex[0] );

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

     GLES31.glBindBuffer(GLES31.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?

 * <p>

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

     {

     mShowNormals = (DistortedLibrary.GLSL >= 300 && 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()

     {

     mVertAttribs = null;

     mVBO.markForDeletion();

     mTFO.markForDeletion();

     }

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

/**

 * Apply all Effects to the vertex mesh. Overwrite the mesh in place.

 * <p>

 * This is a static, permanent modification of the vertices contained in this Mesh. If the effects

 * 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[][] matrix = new float[effects.length][16];

     float[] tmp;

     float[] array = new float[7];

     float x,y,z;

     int numEffects = 0;

     for(MatrixEffect eff: effects)

       {

       if( eff!=null )

         {

         Matrix.setIdentityM(matrix[numEffects],0);

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

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

         numEffects++;

         }

       }

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

       {

       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;

         }

       }

     mTFO.invalidate();

     }

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

/**

 * Sets texture maps for all components of this mesh.

 * <p>

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

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

 * each time.

 * 'maps' needs to be maps[NumComponentsInThisMesh][4]. [0] is the lower-left corner's X, [1]- its Y,

 * [2] - width, [3] - height of the map.

 * For example map[0] = new float { 0.0, 0.5, 0.5, 0.5 } sets the 0th component texture map to the

 * upper-left quadrant of the texture.

 */

   public void setTextureMap(float[][] maps)

     {

     int num_comp = mComponent.size();

     int num_maps = maps.length;

     int min = num_comp<num_maps ? num_comp : num_maps;

     int lastEnd = 0;

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

       {

       if( maps[i]!=null )

         {

         Component comp = mComponent.get(i);

         changeTextureMap(maps[i],comp.mTextureMap,lastEnd,comp.mEndIndex);

         comp.setMap(maps[i]);

         lastEnd = comp.mEndIndex;

         }

       }

     mTFO.invalidate();

     }

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

/**

 * Each mesh has its 'bounding box' - return half of its X-length.

 * <p>

 * In case of all 'simple' Meshes, the bounding box is always 1x1x1 (Sphere, Cubes) or 1x1x0

 * (Rectangles, Triangles, Quad - i.e. all 'flat' Meshes). But this can be something else in case of

 * MeshComponent.

 */

   public float getBoundingX()

    {

    return mBoundingX*mStretchX;

    }

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

/**

 * Each mesh has its 'bounding box' - return half of its Y-length.

 */

   public float getBoundingY()

    {

    return mBoundingY*mStretchY;

    }

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

/**

 * Each mesh has its 'bounding box' - return half of its Z-length.

 */

   public float getBoundingZ()

    {

    return mBoundingZ*mStretchZ;

    }

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

/**

 * Sometimes we want to display a Mesh on a rectangular screen. Then we need to stretch it by

 * different factors in x and y (or z) directions. If we also wanted do display some vertex effects

 * done on this mesh, let's say a bulge done by a Distort effect, and wanted the bulge to be round,

 * (i.e the same in x and y directions) then doing so without this method would be impossible.

 *

 * This sets 'stretch' factors in each 3 dimensions. All vertices of this Mesh will be premultiplied

 * by those factors in the very first line of the Vertex Shader, before any Effects are done on it.

 * Using this we can thus pre-stretch the mesh to aspect ratio equal to the surface we eventually

 * want to display the Mesh on, and this way we can achieve a round Distort bulge!

 *

 * This could also be used to pre-stretch a Rectangles Mesh to a size equal (in pixels) to the bitmap

 * this mesh is textured with - and this lets us work with all Effects in natural, pixel units.

 *

 * @param sx stretch factor in x.

 * @param sy stretch factor in y.

 * @param sz stretch factor in z.

 */

   public void setStretch(float sx, float sy, float sz)

     {

     mStretchX = sx;

     mStretchY = sy;

     mStretchZ = sz;

     }

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

/**

 * Returns the x-factor set by setStretch().

 */

   public float getStretchX()

     {

     return mStretchX;

     }

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

/**

 * Returns the y-factor set by setStretch().

 */

   public float getStretchY()

     {

     return mStretchY;

     }

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

/**

 * Returns the z-factor set by setStretch().

 */

   public float getStretchZ()

     {

     return mStretchZ;

     }

   }