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 java.util.HashMap;

import java.util.LinkedList;

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

/**

 * Any Object which gets uploaded to GPU memory and thus needs to be re-created (transparently to

 * applications!) whenever we lose OpenGL context.

 *

 * Keep all objects created in a static LinkedList. The point: we need to be able to mark

 * Objects for deletion, and delete all marked Objects later at a convenient time (that's

 * because we can only delete from a thread that holds the OpenGL context so here we provide a

 * framework where one is able to mark for deletion at any time and actual deletion takes place

 * on the next render).

*/

  static final int FAILED_TO_CREATE = 1;

  static final int NOT_CREATED_YET  = 2;

  static final int DONT_CREATE      = 3;

  static final int CREATED          = 4;

  static final int TYPE_USER = 0;

  static final int TYPE_TREE = 1;

  static final int TYPE_SYST = 2;

  private static final int JOB_CREATE = 0;

  private static final int JOB_DELETE = 1;

  private class Job

    {

      object = o;

      action = a;

      }

    }

  private static boolean mToDo = false;

  private static long mNextClientID = 0;

  private static long mNextSystemID = 0;

  private final static Object mToDoLock = new Object();

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

  abstract void create();

  abstract void delete();

  abstract void recreate();

  abstract String printDetails();

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

// must be called from a thread holding OpenGL Context

    if( mToDo )

      {

      Job job;

          object = job.object;

          if( job.action==JOB_CREATE )

            {

            object.create();

            mDoneList.add(object);

            }

          else if( job.action==JOB_DELETE )

            {

            object.delete();

            }

        mToDoMap.clear();

        mToDo = false;

      return true;

      }

    return false;

    }

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

        try

          {

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

            {

            object = mDoneList.removeFirst();

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

            object.recreate();

            }

          }

        catch( Exception ex )

          {

          // something else removed an object in the meantime; ignore

          }

      }

    mToDo = true;

    }

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

      {

      synchronized(mDoneLock)

        {

        mToDoMap.clear();

        mDoneList.clear();

        mNextClientID = 0;

        }

      }

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

  @SuppressWarnings("unused")

  static void debugLists()

    {

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

      object.print("");

      }

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

    Job job;

    for(Long key: mToDoMap.keySet())

      {

      job = mToDoMap.get(key);

      job.object.print(job.action==JOB_CREATE ? " create":" delete");

      }

    }

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

  private void print(String msg)

    {

    String str = "ID:"+mID;

    switch(mType)

      {

      case TYPE_SYST: str+=" SYSTEM "; break;

      case TYPE_USER: str+=" USER   "; break;

      case TYPE_TREE: str+=" TREE   "; break;

      default       : str+=" ERROR? ";

      }

    android.util.Log.e("Object", str+printDetails()+msg);

    }

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

    mID  = type==TYPE_SYST ? --mNextSystemID : ++mNextClientID;

    mType= type;

    }

  void markWasCreatedImmediately()

    {

    mDoneList.add(this);

    }

      {

      mDoneList.remove(this);

      }

    synchronized(mToDoLock)

      {

      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.

 */

      {

      mDoneList.remove(this);

      }

    synchronized(mToDoLock)

      {

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

      mToDo = true;

      }

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

/**

 * Return unique ID of this Object.

 */

  public long getID()

    {

    return mID;

    }

}