Distorted Android

import org.distorted.library.main.InternalStackFrameList;

    if( !InternalStackFrameList.isInitialized() || m<=mMax[index] )

  DistortedFramebuffer(int numfbos, int numcolors, int depthStencil, int type, int storage, int width, int height)

    super(width,height,NOT_CREATED_YET,numfbos,numcolors,depthStencil,NOT_CREATED_YET, type, storage);

    this(1,numcolors,depthStencil,type,STORAGE_PRIVATE,width,height);

    this(1,numcolors,depthStencil,TYPE_USER,STORAGE_PRIVATE,width,height);

  private static int mGLSL;

  private static String mGLSL_VERSION;

  private static boolean mOITCompilationAttempted;

  private static int mMaxTextureSize;

 * @param context  Context of the App using the library - used to open up Resources and read Shader code.

 * @param context   Context of the App using the library - used to open up Resources and read Shader code.

 * @param listener  The library will send all (asynchronous!) exceptions there.

    InternalStackFrameList.setInitialized(true);

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

/**

 * Call this so that the Library can initialize its internal data structures.

 * Must be called from Activity.onCreate().

 */

  public static void onCreate()

    {

    onCreate(0);

    }

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

/**

 * Call this so that the Library can initialize its internal data structures.

 * Must be called from Activity.onCreate().

 *

 * @param id id of an Activity that is using the library; anything unique so that the Library can

 *           tell between Activities in case you're going to be using it from more than one.

 */

  public static void onCreate(long id)

    {

    InternalStackFrameList.onCreate(id);

    }

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

/**

 * Call this so that the Library can resume its operations.

 * Must be called from Activity.onResume().

 */

  public static void onResume()

    {

    onCreate(0);

    }

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

/**

 * Call this so that the Library can resume its operations.

 * Must be called from Activity.onResume().

 *

 * @param id id of an Activity that is using the library; anything unique so that the Library can

 *           tell between Activities in case you're going to be using it from more than one.

 */

  public static void onResume(long id)

    {

    InternalStackFrameList.onResume(id);

    }

    onPause(0);

    }

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

/**

 * Call this so that the Library can release the OpenGL related data that needs to be recreated.

 * Must be called from Activity.onPause().

 *

 * @param id id of an Activity that is using the library; anything unique so that the Library can

 *           tell between Activities in case you're going to be using it from more than one.

 */

  public static void onPause(long id)

    {

    InternalStackFrameList.onPause(id);

android.util.Log.e("ON_PAUSE", "id="+id);

 * Must be called from Activity.onDestroy().

    onDestroy(0);

    }

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

/**

 * Call this so that the Library can release its internal data structures.

 * Must be called from Activity.onDestroy().

 *

 * @param id id of an Activity that is using the library; anything unique so that the Library can

 *           tell between Activities in case you're going to be using it from more than one.

 */

  public static void onDestroy(long id)

    {

android.util.Log.e("ON_DESTROY", "id="+id);

    if( InternalStackFrameList.isInitialized() )

      InternalStackFrameList.setInitialized(false);

      InternalStackFrameList.onDestroy(id);

    super(DistortedLibrary.WAIT_FOR_FBO_QUEUE_SIZE,1,BOTH_DEPTH_STENCIL, TYPE_SYST, STORAGE_PRIVATE,1,1);

    super(NOT_CREATED_YET,1,1,type,InternalObject.STORAGE_PRIVATE);

    super(InternalObject.TYPE_USER, InternalObject.STORAGE_PRIVATE );

      removeFromDone();

  static final int STORAGE_COMMON  = 0;

  static final int STORAGE_PRIVATE = 1;

  static final int JOB_CREATE = 0;

  static final int JOB_DELETE = 1;

  private int mStorage;

  void print(String msg)

  InternalObject(int type, int storage)

    mType    = type;

    mStorage = storage;

    mID      = InternalStackFrameList.getCurrentFrame().generateID(mType,mStorage);

    InternalStackFrameList.getCurrentFrame().addToDoneList(this,mStorage);

    InternalStackFrameList.markFor(this,mID,mStorage,JOB_CREATE);

    }

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

  void removeFromDone()

    {

    InternalStackFrameList.removeFromDone(this,mStorage);

    InternalStackFrameList.markFor(this,mID,mStorage,JOB_DELETE);

  InternalOutputSurface(int width, int height, int createColor, int numfbos, int numcolors, int depthStencil, int fbo, int type, int storage)

    super(createColor,numfbos,numcolors,type,storage);

    mBuffer[quality] = new DistortedFramebuffer(queueSize,2,BOTH_DEPTH_STENCIL,TYPE_SYST, STORAGE_COMMON, (int)(width*mipmap), (int)(height*mipmap) );

    InternalStackFrameList.toDo(); // create the FBOs immediately. This is safe as we must be holding the OpenGL context now.

    InternalStackFrameList.toDo();

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

// Copyright 2020 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.main;

import java.util.HashMap;

import java.util.LinkedList;

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

public class InternalStackFrame

{

  private static class Job

    {

    InternalObject object;

    int action;

    Job(InternalObject o, int a)

      {

      object = o;

      action = a;

      }

    }

  private static LinkedList<InternalObject> mCommonDoneList = new LinkedList<>(); //

  private static HashMap<Long,Job> mCommonToDoMap           = new HashMap<>();    // Common

  private static long mCommonNextClientID                   = 0;                  // InternalObject

  private static long mCommonNextSystemID                   = 0;                  // (postprocessing)

  private LinkedList<InternalObject> mDoneList; //

  private HashMap<Long,Job> mToDoMap;           //

  private long mNextClientID;                   // InternalObject

  private long mNextSystemID;                   //

  private long mTaskId;                         //

  private static boolean mInitialized;          // DistortedLibrary

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

  InternalStackFrame(long taskID)

    {

    mDoneList     = new LinkedList<>();

    mToDoMap      = new HashMap<>();

    mNextClientID = 0;

    mNextSystemID = 0;

    mTaskId       = taskID;

    }

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

  long getTaskId()

    {

    return mTaskId;

    }

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

  static void onPauseCommon()

    {

    onPauseGeneric(mCommonDoneList,mCommonToDoMap);

    }

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

  void onPause()

    {

    onPauseGeneric(mDoneList,mToDoMap);

    }

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

  static void onPauseGeneric(LinkedList<InternalObject> list, HashMap<Long,Job> map)

    {

    int num = list.size();

    try

      {

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

        {

        InternalObject object = list.removeFirst();

        Job job = new Job(object, InternalObject.JOB_CREATE);

        map.put(object.getID(),job);

        object.recreate();

        }

      }

    catch( Exception ignored )

      {

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

      }

    }

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

  void toDo()

    {

    toDoGeneric(mDoneList,mToDoMap);

    }

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

  static void toDoCommon()

    {

    toDoGeneric(mCommonDoneList,mCommonToDoMap);

    }

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

  static void toDoGeneric(LinkedList<InternalObject> list, HashMap<Long,Job> map)

    {

    for(Long key: map.keySet())

      {

      Job job = map.get(key);

      InternalObject object = job.object;

      if( job.action==InternalObject.JOB_CREATE )

        {

        object.create();

        list.add(object);

        }

      else if( job.action==InternalObject.JOB_DELETE )

        {

        object.delete();

        }

      }

    map.clear();

    }

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

  static void cleanCommon()

    {

    mCommonDoneList.clear();

    mCommonToDoMap.clear();

    mCommonNextClientID = 0;

    mCommonNextSystemID = 0;

    }

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

  long generateID(int type, int storage)

    {

    if( storage==InternalObject.STORAGE_PRIVATE )

      {

      return type==InternalObject.TYPE_SYST ? --mNextSystemID : ++mNextClientID;

      }

    else

      {

      return type==InternalObject.TYPE_SYST ? --mCommonNextSystemID : ++mCommonNextClientID;

      }

    }

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

  void addToDoneList(InternalObject obj, int storage)

    {

    if( storage==InternalObject.STORAGE_PRIVATE )

      {

      if( !mDoneList.contains(obj) )

        {

        mDoneList.add(obj);

        }

      }

    else

      {

      if( !mCommonDoneList.contains(obj) ) mCommonDoneList.add(obj);

      }

    }

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

  void removeFromDoneList(InternalObject obj, int storage)

    {

    if( storage==InternalObject.STORAGE_PRIVATE )

      {

      mDoneList.remove(obj);

      }

    else

      {

      mCommonDoneList.remove(obj);

      }

    }

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

  void markFor(InternalObject obj, long id, int storage, int jobType)

    {

    if( storage==InternalObject.STORAGE_PRIVATE )

      {

      mDoneList.remove(obj);

      mToDoMap.put(id, new Job(obj,jobType) );

      }

    else

      {

      mCommonDoneList.remove(obj);

      mCommonToDoMap.put(id, new Job(obj,jobType) );

      }

    }

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

  boolean isInitialized()

    {

    return mInitialized;

    }

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

  void setInitialized(boolean init)

    {

    mInitialized = init;

    }

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

  void debugLists(String frameMarker)

    {

    debugListsGeneric(mDoneList,mToDoMap,frameMarker);

    }

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

  static void debugCommonList()

    {

    debugListsGeneric(mCommonDoneList,mCommonToDoMap,"Common");

    }

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

  static void debugListsGeneric(LinkedList<InternalObject> list, HashMap<Long,Job> map,String frameMarker)

    {

    android.util.Log.e("Object", frameMarker);

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

    for(InternalObject object : list)

      {

      object.print("  ");

      }

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

    Job job;

    for(Long key: map.keySet())

      {

      job = map.get(key);

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

      }

    }

  }

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

// Copyright 2020 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.main;

import java.util.ArrayList;

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

public class InternalStackFrameList

{

  private final static Object mLock = new Object();

  private static boolean mToDo = false;

  private static InternalStackFrame mCurrentFrame = null;

  private static ArrayList<InternalStackFrame> mFrameList = new ArrayList<>();

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

  static void onCreate(long taskId)

    {

    int num = mFrameList.size();

    InternalStackFrame frame;

    boolean found = false;

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

      {

      frame = mFrameList.get(i);

      if( frame.getTaskId() == taskId )

        {

        mCurrentFrame = frame;

        found = true;

        break;

        }

      }

    if( !found )

      {

      synchronized(mLock)

        {

        mCurrentFrame = new InternalStackFrame(taskId);

        mFrameList.add(mCurrentFrame);

        }

      }

    mCurrentFrame.setInitialized(false);

    }

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

  static void onResume(long taskId)

    {

    int num = mFrameList.size();

    InternalStackFrame frame;

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

      {

      frame = mFrameList.get(i);

      if( frame.getTaskId() == taskId )

        {

        mCurrentFrame = frame;

        break;

        }

      }

    mCurrentFrame.setInitialized(false);

    }

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

  static void onPause(long taskId)

    {

    int num = mFrameList.size();

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

      {

      if( mFrameList.get(i).getTaskId() == taskId )

        {

        synchronized(mLock)

          {

          mCurrentFrame.onPause();

          InternalStackFrame.onPauseCommon();

          mToDo = true;

          }

        break;

        }

      }

    }

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

  static void onDestroy(long taskId)

    {

    int num = mFrameList.size();

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

      {

      if( mFrameList.get(i).getTaskId() == taskId )

        {

        synchronized(mLock)

          {

          mFrameList.remove(i);

          if( num==1 ) InternalStackFrame.cleanCommon();

          }

        break;

        }

      }

    }

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

  @SuppressWarnings("unused")

  static void debugLists()

    {

    int num = mFrameList.size();

    InternalStackFrame frame;

    InternalStackFrame.debugCommonList();

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

      {

      frame = mFrameList.get(i);

      frame.debugLists("frame "+i);

      }

    }

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

// must be called from a thread holding OpenGL Context

  static boolean toDo()

    {

    if( mToDo )

      {

      mToDo = false;

      synchronized(mLock)

        {

        mCurrentFrame.toDo();

        InternalStackFrame.toDoCommon();

        }

      return true;

      }

    return false;

    }

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

  static void markFor(InternalObject obj, long id, int storage, int job)

    {

    synchronized(mLock)

      {

      mCurrentFrame.markFor(obj,id,storage,job);

      mToDo = true;

      }

    }

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

  static void removeFromDone(InternalObject obj, int storage)

    {

    synchronized(mLock)

      {

      mCurrentFrame.removeFromDoneList(obj,storage);

      }

    }

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

  static InternalStackFrame getCurrentFrame()

    {

    return mCurrentFrame;

    }

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

  static void setInitialized(boolean init)

    {

    mCurrentFrame.setInitialized(init);

    }

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

// PUBLIC API

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

  public static boolean isInitialized()

    {

    return mCurrentFrame.isInitialized();

    }

}

  InternalSurface(int create, int numfbos, int numcolors, int type, int storage)

    super(type,storage);