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

import org.distorted.library.program.DistortedProgram;

import org.distorted.library.type.Static4D;

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

   {

   // 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 boolean mNeedsAdjustment;

   private static class Component

     {

     private int mEndIndex;

     private Static4D mTextureMap;

     private EffectQueueVertex mQueue;

     Component(int end)

       {

       mEndIndex  = end;

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

       mQueue     = new EffectQueueVertex();

       }

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

       mQueue = new EffectQueueVertex(original.mQueue);

       }

     void setMap(Static4D map)

       {

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

       }

     }

   private ArrayList<Component> mComponent;

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

   MeshBase()

     {

     mShowNormals     = false;

     mInflate         = 0.0f;

     mNeedsAdjustment = false;

     mComponent       = new ArrayList<>();

     mVBO = 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)

     {

     mShowNormals     = original.mShowNormals;

     mInflate         = original.mInflate;

     mNeedsAdjustment = original.mNeedsAdjustment;

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

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

     mNumVertices = original.mNumVertices;

     mVertAttribs = new float[mNumVertices*VERT_ATTRIBS];

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

     mVBO.invalidate();

     mTFO.invalidate();

     }

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

   int numComponents()

     {

     return mComponent.size();

     }

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

// 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 numComponents, numVertices, numMeshes = meshes.length;

     int origVertices = mNumVertices;

     // compute new numVertices; take care of Components

     if( origVertices>0 )

       {

       numComponents = mComponent.size();

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

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

       }

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

         comp.mEndIndex += mNumVertices;

         mComponent.add(comp);

         }

       numVertices = mesh.mNumVertices;

       if( mNumVertices==0 )

         {

         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[] newAttribs = new float[VERT_ATTRIBS*mNumVertices];

     numVertices = origVertices;

     if( origVertices>0 )

       {

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

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

       origVertices++;

       if( numVertices%2==1 )

         {

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

         origVertices++;

         }

       }

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

       {

       mesh = meshes[i];

       numVertices = 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*numVertices);

       origVertices+=numVertices;

       if( i<numMeshes-1 )

         {

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

         origVertices++;

         if( numVertices%2==1 )

           {

           System.arraycopy(mesh.mVertAttribs, VERT_ATTRIBS*(numVertices-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 void copyTransformToVertex()

     {

     float posX, posY, posZ, norX, norY, norZ;

     FloatBuffer feedback=null;

     ByteBuffer buffer = (ByteBuffer)GLES30.glMapBufferRange( GLES30.GL_TRANSFORM_FEEDBACK_BUFFER, 0, TRAN_SIZE*mNumVertices,

                                                              GLES30.GL_MAP_READ_BIT);

     if( buffer!=null )

       {

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

       }

     else

       {

       int error = GLES30.glGetError();

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

       }

     if( feedback!=null )

       {

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

         {

         mVertAttribs[vertex*VERT_ATTRIBS + POS_ATTRIB     ] = feedback.get(6*vertex  );

         mVertAttribs[vertex*VERT_ATTRIBS + POS_ATTRIB + 1 ] = feedback.get(6*vertex+1);

         mVertAttribs[vertex*VERT_ATTRIBS + POS_ATTRIB + 2 ] = feedback.get(6*vertex+2);

         mVertAttribs[vertex*VERT_ATTRIBS + NOR_ATTRIB     ] = feedback.get(6*vertex+3);

         mVertAttribs[vertex*VERT_ATTRIBS + NOR_ATTRIB + 1 ] = feedback.get(6*vertex+4);

         mVertAttribs[vertex*VERT_ATTRIBS + NOR_ATTRIB + 2 ] = feedback.get(6*vertex+5);

         }

       mVBO.update(mVertAttribs);

       }

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

       {

       mComponent.get(i).mQueue.send(0.0f,3);

       }

     }

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

/**

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

     {

     if( mNeedsAdjustment )

       {

       mNeedsAdjustment = false;

       DistortedLibrary.adjustVertices(this);

       }

     int index = mVBO.createImmediately(mNumVertices*VERT_SIZE, mVertAttribs);

     GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, index );

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

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

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

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

     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.createImmediately(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;

     }

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

// 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 = 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 a Vertex Effect to the vertex mesh.

 * <p>

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

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

 *

 * We would call this several times building up a list of Effects to do. This list of effects gets

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

 *

 * @param effect Vertex Effect to apply to the Mesh.

 */

   public void apply(VertexEffect effect)

     {

     int numComp = mComponent.size();

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

       {

       mComponent.get(i).mQueue.add(effect);

       }

     mNeedsAdjustment = true;

     }

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

/**

 * Sets texture maps for (some of) the components of this mesh.

 * <p>

 * Format: ( x of lower-left corner, y of lower-left corner, width, height ).

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

 * upper-left quadrant of the texture.

 * <p>

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

 */

   public void setTextureMap(Static4D[] maps)

     {

     int num_comp = mComponent.size();

     int num_maps = maps.length;

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

     int vertex = 0;

     Static4D newMap, oldMap;

     Component comp;

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

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

       {

       newMap = maps[i];

       comp = mComponent.get(i);

       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*VERT_ATTRIBS+TEX_ATTRIB ; vertex<=comp.mEndIndex; vertex++, index+=VERT_ATTRIBS)

             {

             mVertAttribs[index  ] = ratW*mVertAttribs[index  ] + movX;

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

             }

           comp.setMap(newMap);

           }

         }

       vertex= comp.mEndIndex+1;

       }

     mVBO.invalidate();

     }

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

/**

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

     }

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

/**

 * Deep copy

 */

   public abstract MeshBase deepCopy();

   }