Distorted Android

        iD = (InternalStackFrameList.getNextEffectID() shl EffectType.LENGTH)+type.ordinal

        val w = buffer.width.toFloat()

        val h = buffer.height.toFloat()

        val n = 1.0f-buffer.near

            val map = InternalStackFrameList.getMap()

                iD = InternalStackFrameList.getNextQueueID()

        val width   = buffer.width

        val height  = buffer.height

  void create()

  void delete()

  void recreate()

      GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );

      GLES30.glUniform2ui(mMainOITSizeH, surface.mWidth, surface.mHeight);

      GLES30.glUniform1ui(mMainOITNumRecordsH, (int)(mBufferSize*surface.mWidth*surface.mHeight) );

      GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );

      GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );

      GLES30.glUniform1f( mBlitDepthH , 1.0f-surface.mNear);

      GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );

      int size = (int)(surface.mWidth*surface.mHeight*(3*mBufferSize+1)*4);

    float overflow = counter/(mBufferSize*surface.mWidth*surface.mHeight);

      int size = (int)(surface.mWidth*surface.mHeight*(3*mBufferSize+1)*4);

    GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );

    GLES30.glUniform2ui(mOITClearSizeH, surface.mWidth, surface.mHeight);

      GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );

      GLES30.glUniform2ui(mOITBuildSizeH, surface.mWidth, surface.mHeight);

      GLES30.glUniform1ui(mOITBuildNumRecordsH, (int)(mBufferSize*surface.mWidth*surface.mHeight) );

      GLES30.glUniform1f(mOITBuildDepthH , 1.0f-surface.mNear);

      GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );

      GLES30.glUniform2ui(mOITCollapseSizeH, surface.mWidth, surface.mHeight);

      GLES30.glUniform1f( mOITCollapseDepthH , 1.0f-surface.mNear);

      GLES30.glViewport(0, 0, surface.mWidth, surface.mHeight );

      GLES30.glUniform2ui(mOITRenderSizeH, surface.mWidth, surface.mHeight);

      GLES30.glUniform1f( mOITRenderDepthH , 1.0f-surface.mNear);

        width = fbo.mWidth;

        height= fbo.mHeight;

          mDebugWidth = (int)(mWidth*DEBUG_SCR_FRAC);

          mDebugHeight= (int)(mWidth*DEBUG_SCR_FRAC*DEBUG_FRAC);

      mMoveVector.set( (-mWidth+mDebugWidth)*0.5f +mDebugGap, (mHeight-mDebugHeight)*0.5f -mDebugGap, 0);

    int width     = (int)(mWidth*DEBUG_SCR_FRAC);

    int height    = (int)(mWidth*DEBUG_SCR_FRAC*DEBUG_FRAC);

  void create()

  void delete()

  void recreate()

package org.distorted.library.main;

import android.opengl.GLES30;

import java.nio.Buffer;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

import java.nio.IntBuffer;

 * <p>

public class InternalBuffer extends InternalObject

  {

  private static final int DONE     = 0;

  private static final int RECREATE = 1;

  private static final int UPDATE   = 2;

  private int mStatus, mSize;

  private final int[] mIndex;

  private final int mTarget, mUsage;

  private Buffer mBuffer;

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

  public InternalBuffer()

    super(InternalObject.TYPE_USER, InternalObject.STORAGE_PRIVATE );

    mIndex  = new int[1];

    mTarget = GLES30.GL_UNIFORM_BUFFER;

    mUsage  = GLES30.GL_STATIC_DRAW;

    mBuffer = null;

    mSize   = 0;

    mStatus = RECREATE;

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

  public InternalBuffer(int target, int usage)

    super(InternalObject.TYPE_USER, InternalObject.STORAGE_PRIVATE );

    mIndex  = new int[1];

    mTarget = target;

    mUsage  = usage;

    mBuffer = null;

    mSize   = 0;

    mStatus = RECREATE;

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

// must be called from a thread holding OpenGL Context.

  public int createImmediatelyFloat(int size, float[] buffer)

    if( (mStatus & RECREATE) != 0 )

      {

      mSize= size;

      if( buffer!=null )

        FloatBuffer buf = ByteBuffer.allocateDirect(size).order(ByteOrder.nativeOrder()).asFloatBuffer();

        buf.put(buffer).position(0);

        mBuffer = buf;

      else

        mBuffer = null;

      GLES30.glGenBuffers( 1, mIndex, 0);

      GLES30.glBindBuffer( mTarget, mIndex[0]);

      GLES30.glBufferData( mTarget, mSize, mBuffer, mUsage);

      GLES30.glBindBuffer( mTarget, 0);

      markWasCreatedImmediately();

      }

    else if( (mStatus & UPDATE) != 0 )

      {

      updateFloat(buffer);

      }

    mStatus = DONE;

    return mIndex[0];

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

// must be called from a thread holding OpenGL Context.

  public int createImmediatelyInt(int size, int[] buffer)

    if( (mStatus & RECREATE) != 0 )

      {

      mSize= size;

      if( buffer!=null )

        IntBuffer buf = ByteBuffer.allocateDirect(size).order(ByteOrder.nativeOrder()).asIntBuffer();

        buf.put(buffer).position(0);

        mBuffer = buf;

      else

        mBuffer = null;

      GLES30.glGenBuffers( 1, mIndex, 0);

      GLES30.glBindBuffer( mTarget,  mIndex[0]);

      GLES30.glBufferData( mTarget, mSize, mBuffer, mUsage);

      GLES30.glBindBuffer( mTarget,  0);

      markWasCreatedImmediately();

      }

    else if( (mStatus & UPDATE) != 0  )

      {

      updateInt(buffer);

      }

    mStatus = DONE;

    return mIndex[0];

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

// buffer non-null!!

  public void updateFloat(float[] buffer)

    ((FloatBuffer)mBuffer).put(buffer).position(0);

    GLES30.glBindBuffer( mTarget, mIndex[0]);

    GLES30.glBufferData( mTarget, mSize, mBuffer, mUsage);

    GLES30.glBindBuffer( mTarget, 0);

    mStatus &= (~UPDATE);

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

// buffer non-null!!

  public void updateInt(int[] buffer)

    ((IntBuffer)mBuffer).put(buffer).position(0);

    GLES30.glBindBuffer( mTarget, mIndex[0]);

    GLES30.glBufferData( mTarget, mSize, mBuffer, mUsage);

    GLES30.glBindBuffer( mTarget, 0);

    mStatus &= (~UPDATE);

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

  public void invalidate()

    mStatus |= UPDATE;

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

// Intentionally empty, no need to do anything here since it will be done in createImmediatelyXXX().

// In fact, recreating a Mesh's mVBO1 here - rather than in createImmediatelyFloat - was the reason

// of the 'disappearing cube after the mesh has changed from nice to simple' bug. I don't quite

// understand why TBH.

  void create()

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

// must be called from a thread holding OpenGL Context

  void delete()

    GLES30.glDeleteBuffers(1, mIndex, 0);

    mStatus |= RECREATE;

    removeFromDone();

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

  public void recreate()

    mStatus |= RECREATE;

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

// debugging only

  String printDetails()

    return getClass().getSimpleName();

  }

package org.distorted.library.main;

import org.distorted.library.mesh.MeshBase;

import java.util.ArrayList;

class InternalChildrenList implements InternalMaster.Slave

  {

  private static final int ATTACH = 0;

  private static final int DETACH = 1;

  private static final int DETALL = 2;

  private static final int SORT   = 3;

  private static class Job

    int type;

    DistortedNode node;

    Job(int t, DistortedNode n)

      {

      type = t;

      node = n;

      }

  private final ArrayList<Job> mJobs;

  private final InternalChildrenList.Parent mParent;

  private ArrayList<DistortedNode> mChildren;

  private int mNumChildren;

  public interface Parent

    {

    void adjustIsomorphism();

    }

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

  InternalChildrenList(InternalChildrenList.Parent parent)

    mParent = parent;

    mJobs = new ArrayList<>();

    mChildren = null;

    mNumChildren = 0;

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

  int getNumChildren()

    return mNumChildren;

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

  DistortedNode getChild(int index)

    return mChildren.get(index);

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

  void rearrangeByBuckets(int index,long bucket)

    DistortedNode child = mChildren.remove(index);

    int i;

    for(i=0; i<index; i++)

      {

      if( mChildren.get(i).getBucket() > bucket ) break;

      }

    mChildren.add(i,child);

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

// Can make this logarithmic but the typical number of children is very small anyway.

//

// We want to keep same buckets next to each other, while avoiding changes in order of the children

// (if possible!)

// 2022/10/25: removed keeping bucket 0 (i.e. non-postprocessed children) always in the front -

// we don't need it (given the fixes to renderChildren() )

  private void addSortingByBuckets(DistortedNode newChild)

    int i;

    long bucket = newChild.getBucket();

    boolean thisSame,lastSame = false;

    for(i=0; i<mNumChildren; i++)

      {

      thisSame= (mChildren.get(i).getBucket()==bucket);

      if( lastSame && !thisSame ) break;

      lastSame = thisSame;

      }

    mChildren.add(i,newChild);

    mNumChildren++;

    }

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

  void attach(DistortedNode node)

    {

    node.resetLastTime();

    mJobs.add(new Job(ATTACH,node));

    InternalMaster.newSlave(this);

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

  DistortedNode attach(InternalSurface surface, DistortedEffects effects, MeshBase mesh)

    DistortedNode node = new DistortedNode(surface,effects,mesh);

    mJobs.add(new Job(ATTACH,node));

    InternalMaster.newSlave(this);

    return node;

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

  void detach(DistortedNode node)

    mJobs.add(new Job(DETACH,node));

    InternalMaster.newSlave(this);

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

  void detach(DistortedEffects effects)

    long id = effects.getID();

    DistortedNode node;

    boolean detached = false;

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

      {

      node = mChildren.get(i);

      if( node.getEffects().getID()==id )

        detached = true;

        mJobs.add(new Job(DETACH,node));

        InternalMaster.newSlave(this);

        break;

      }

    if( !detached )

      {

      // if we failed to detach any, it still might be the case that

      // there's an ATTACH job that we need to cancel.

      int num = mJobs.size();

      Job job;

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

        job = mJobs.get(i);

        if( job.type==ATTACH && job.node.getEffects()==effects )

          {

          mJobs.remove(i);

          break;

          }

      }

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

  void detachAll()

    mJobs.add(new Job(DETALL,null));

    InternalMaster.newSlave(this);

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

/**

 * This is not really part of the public API. Has to be public only because it is a part of the

 * DistortedSlave interface, which should really be a class that we extend here instead but

 * Java has no multiple inheritance.

 *

 * @y.exclude

 */

  public void doWork()

    int num = mJobs.size();

    if( num>0 )

      {

      Job job;

      int numChanges=0;

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

        job = mJobs.remove(0);

        switch(job.type)

          {

          case ATTACH: numChanges++;

                       if( mChildren==null ) mChildren = new ArrayList<>(2);

                       job.node.setParent(mParent);

                       addSortingByBuckets(job.node);

                       break;

          case DETACH: numChanges++;

                       if( mNumChildren>0 && mChildren.remove(job.node) )

                         {

                         job.node.setParent(null);

                         mNumChildren--;

                         }

                       break;

          case DETALL: numChanges++;

                       if( mNumChildren>0 )

                         {

                         DistortedNode tmp;

                         for(int j=mNumChildren-1; j>=0; j--)

                           {

                           tmp = mChildren.remove(j);

                           tmp.setParent(null);

                           }

                         mNumChildren = 0;

                         }

                       break;

          case SORT  : mChildren.remove(job.node);

                       addSortingByBuckets(job.node);

                       break;

          }

      if( numChanges>0 ) mParent.adjustIsomorphism();

      }

  }

package org.distorted.library.main;

import java.util.ArrayList;

 * <p>

public class InternalMaster

  {

  /**

   * Not part of public API, do not document (public only because has to be used in PostprocessEffects)

   *

   * @y.exclude

   */

  public interface Slave

    {

    void doWork();

    }

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

  private InternalMaster()

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

  static boolean toDo()

    Slave slave;

    ArrayList<Slave> list = InternalStackFrameList.getSet();

    int numSlaves = list.size();

    try

      {

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

        slave = list.remove(0);

        if( slave!=null ) slave.doWork();

      }

    catch(IndexOutOfBoundsException ie)

      {

      // onDestroy must have been called, ignore

      }

    return numSlaves>0;

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

  public static void newSlave(Slave s)

    ArrayList<Slave> list = InternalStackFrameList.getSet();

    int num = list.size();

    boolean found = false;

    Slave tmp;

    try

      {

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

        tmp = list.get(i);

        if( tmp==s )

          {

          found = true;

          break;

          }

      }

    catch(IndexOutOfBoundsException ie)

      {

      // onDestroy must have been called, ignore

      }

    if( !found ) list.add(s);

  }

package org.distorted.library.main;

import java.util.ArrayList;

class InternalNodeData

  {

  private final ArrayList<Long> mKey;

  private int numPointingNodes;

  private long currTime;

  final long ID;

  DistortedFramebuffer mFBO;

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

  InternalNodeData(long id, ArrayList<Long> k)

    {

    ID              = id;

    mKey            = k;

    numPointingNodes= 1;

    currTime        =-1;

    mFBO            = null;

    }

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

  static InternalNodeData returnData(ArrayList<Long> list)

    InternalNodeData data = InternalStackFrameList.getMapID(list);

    if( data!=null )

      {

      data.numPointingNodes++;

      }

    else

      {

      data = InternalStackFrameList.putNewDataToMap(list);

      }

    return data;

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

  boolean removeData()

    if( --numPointingNodes==0 )

      {

      InternalStackFrameList.removeKeyFromMap(mKey);

        return mFBO != null;

      }

    return false;

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

  boolean notRenderedYetAtThisTime(long time)

    if( currTime!=time )

      {

      currTime = time;

      return true;

      }

    return false;

  }

package org.distorted.library.main;

 * <p>

*/

abstract class InternalObject

  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;

  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 final long mID;

  private final int mType;

  private final int mStorage;

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

  abstract void create();

  abstract void delete();

  abstract void recreate();

  abstract String printDetails();

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

  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? ";

      }

    DistortedLibrary.logMessage("InternalObject: "+str+printDetails()+msg);

    }

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

  InternalObject(int type, int storage)

    {

    mType    = type;

    mStorage = storage;

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

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

  void markWasCreatedImmediately()

    {

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

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

  void markForCreation()

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

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

  void removeFromDone()

    InternalStackFrameList.removeFromDone(this,mStorage);