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;

import android.opengl.GLES30;

import java.nio.FloatBuffer;

import java.util.HashMap;

import java.util.LinkedList;

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

/**

 * Abstract class which represents a Mesh, ie 3 arrays of Vertex attributes: 1) positions

 * 2) normals 3) texture coordinates.

 * <p>

 * If you want to render to a particular shape, extend from here, construct the three FloatBuffers and

 * provide correct dataLength, i.e. the number of vertices.

 */

public abstract class MeshObject

   {

   static final int BYTES_PER_FLOAT   = 4; //

   static final int POSITION_DATA_SIZE= 3; // Size of the position data in elements

   static final int NORMAL_DATA_SIZE  = 3; // Size of the normal data in elements.

   static final int TEX_DATA_SIZE     = 2; // Size of the texture coordinate data in elements.

   ///// CREATING/DELETING Vertex Buffer Objects ///////////////////////////

   private static final int JOB_CREATE = 0;

   private static final int JOB_DELETE = 1;

   private class Job

     {

     MeshObject mesh;

     int action;

     Job(MeshObject o, int a)

       {

       mesh   = o;

       action = a;

       }

     }

   private static boolean mToDo = false;

   private static LinkedList<MeshObject> mDoneList = new LinkedList<>();

   private static HashMap<Long,Job> mToDoMap = new HashMap<>();

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

   private static long mNextID = 0;

   private long mID;

   int dataLength;

   FloatBuffer mMeshPositions, mMeshNormals, mMeshTexture;

   int[] mPosVBO = new int[1];

   int[] mNorVBO = new int[1];

   int[] mTexVBO = new int[1];

   final float zFactor; // strange workaround for the fact that we need to somehow store the 'depth'

                        // of the Mesh. Used in DistortedEffects. See DistortedTexture.getDepth().

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

   MeshObject(float factor)

     {

     zFactor = factor;

     mID     = mNextID++;

     recreate();

     mToDoMap.put(mID, new Job(this,JOB_CREATE) );

     mToDo = true;

     }

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

// must be called from a thread holding OpenGL Context

   static synchronized boolean toDo()

     {

     if( mToDo )

       {

       Job job;

       MeshObject mesh;

       for(Long key: mToDoMap.keySet())

         {

         job = mToDoMap.get(key);

         mesh = job.mesh;

         //android.util.Log.d("MESH", "  ---> need to "+(job.action==JOB_CREATE ? "create":"delete") );

         if( job.action==JOB_CREATE )

           {

           mesh.create();

           mDoneList.add(mesh);

           }

         else if( job.action==JOB_DELETE )

           {

           mesh.delete();

           }

         }

       mToDoMap.clear();

       mToDo = false;

       return true;

       }

     return false;

     }

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

// must be called from a thread holding OpenGL Context

//

// Do NOT release mMeshPositions etc as we will need them when we need to re-create the buffers after

// a loss of OpenGL context!

   private void create()

     {

     if( mPosVBO[0]<0 )

       {

       GLES30.glGenBuffers(1, mPosVBO, 0);

       GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, mPosVBO[0]);

       GLES30.glBufferData(GLES30.GL_ARRAY_BUFFER, dataLength*POSITION_DATA_SIZE*BYTES_PER_FLOAT, mMeshPositions, GLES30.GL_STATIC_READ);

       }

     if( mNorVBO[0]<0 )

       {

       GLES30.glGenBuffers(1, mNorVBO, 0);

       GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, mNorVBO[0]);

       GLES30.glBufferData(GLES30.GL_ARRAY_BUFFER, dataLength*  NORMAL_DATA_SIZE*BYTES_PER_FLOAT, mMeshNormals  , GLES30.GL_STATIC_READ);

       }

     if( mTexVBO[0]<0 )

       {

       GLES30.glGenBuffers(1, mTexVBO, 0);

       GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, mTexVBO[0]);

       GLES30.glBufferData(GLES30.GL_ARRAY_BUFFER, dataLength*    TEX_DATA_SIZE*BYTES_PER_FLOAT, mMeshTexture  , GLES30.GL_STATIC_READ);

       }

     GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, 0);

     }

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

// must be called from a thread holding OpenGL Context

   private void delete()

     {

     if( mPosVBO[0]>=0 )

       {

       GLES30.glDeleteBuffers(1, mPosVBO, 0);

       mPosVBO[0] = -1;

       }

     if( mNorVBO[0]>=0 )

       {

       GLES30.glDeleteBuffers(1, mNorVBO, 0);

       mNorVBO[0] = -1;

       }

     if( mTexVBO[0]>=0 )

       {

       GLES30.glDeleteBuffers(1, mTexVBO, 0);

       mTexVBO[0] = -1;

       }

     }

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

   private void recreate()

     {

     mPosVBO[0] = -1;

     mNorVBO[0] = -1;

     mTexVBO[0] = -1;

     }

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

  static synchronized void onPause()

    {

    MeshObject mesh;

    int num = mDoneList.size();

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

      {

      mesh = mDoneList.removeFirst();

      mToDoMap.put(mesh.getID(), mesh.new Job(mesh,JOB_CREATE) );

      mesh.recreate();

      }

    mToDo = true;

    }

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

  static synchronized void onDestroy()

    {

    mToDoMap.clear();

    mDoneList.clear();

    mToDo = true;

    mNextID = 0;

    }

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

  @SuppressWarnings("unused")

  static void debugLists()

    {

    android.util.Log.e("Mesh", "Done list:");

    MeshObject mesh;

    int num = mDoneList.size();

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

      {

      mesh = mDoneList.get(i);

      mesh.print(i, "");

      }

    android.util.Log.e("Mesh", "ToDo list:");

    Job job;

    int i=0;

    for(Long key: mToDoMap.keySet())

      {

      job = mToDoMap.get(key);

      job.mesh.print(i++, job.action==JOB_CREATE ? " create":" delete");

      }

    }

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

  private void print(int i, String extra)

    {

    String str;

         if( this instanceof MeshFlat ) str = (i+": MeshFlat  ");

    else if( this instanceof MeshCubes) str = (i+": MeshCubes ");

    else                                str = (i+": UNKNOWN   ");

    str += ( "dataLength: "+dataLength+" meshID:"+getID());

    android.util.Log.e("Mesh", str+extra);

    }

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

/**

 * Get the minimal set of Vertices which have the same convex hull as the whole set.

 * <p>

 * In case of Flat Meshes, the set is obviously just the 4 corners. In case of the Cubes Mesh,

 * it is a subset of the set of each rightmost- and leftmost- corners in each row.

 * <p>

 * This is used to be able to quickly compute, in window coordinates, the Mesh'es bounding rectangle.

 */

   abstract float[] getBoundingVertices();

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

   synchronized void markForCreation()

     {

     mDoneList.remove(this);

     mToDoMap.put(mID, new Job(this,JOB_CREATE) );

     mToDo = true;

     }

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

// PUBLIC API

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

/**

 * Mark the underlying OpenGL object for deletion. Actual deletion will take place on the next render.

 */

   synchronized public void markForDeletion()

     {

     mDoneList.remove(this);

     mToDoMap.put(mID, new Job(this,JOB_DELETE) );

     mToDo = true;

     }

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

/**

 * Return unique ID of this Mesh.

 */

   public long getID()

    {

    return mID;

    }

   }