Distorted Android

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

// Copyright 2018 Leszek Koltunski  leszek@koltunski.pl                                          //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// This library is free software; you can redistribute it and/or                                 //

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

//                                                                                               //

// This library 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                             //

// Lesser General Public License for more details.                                               //

//                                                                                               //

// You should have received a copy of the GNU Lesser General Public                              //

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

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

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;

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

/**

 * Implements OpenGL buffer object such as GL_ARRAY_BUFFER or GL_TRANSFORM_FEEDBACK_BUFFER.

 * Main point: deal with Android lifecycle and recreate the buffer on loss of OpenGL context.

 * <p>

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

 *

 * @y.exclude

 */

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

    }

  }

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

// Copyright 2019 Leszek Koltunski  leszek@koltunski.pl                                          //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// This library is free software; you can redistribute it and/or                                 //

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

//                                                                                               //

// This library 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                             //

// Lesser General Public License for more details.                                               //

//                                                                                               //

// You should have received a copy of the GNU Lesser General Public                              //

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

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

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

      }

    }

  }

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

// Copyright 2016 Leszek Koltunski  leszek@koltunski.pl                                          //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// This library is free software; you can redistribute it and/or                                 //

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

//                                                                                               //

// This library 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                             //

// Lesser General Public License for more details.                                               //

//                                                                                               //

// You should have received a copy of the GNU Lesser General Public                              //

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

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

package org.distorted.library.main;

import java.util.ArrayList;

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

/**

 * This static class handles assigning jobs to other classes. It does it once, at the beginning of

 * each frame.

 * <p>

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

 *

 * @y.exclude

 */

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

    }

  }

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

// Copyright 2019 Leszek Koltunski  leszek@koltunski.pl                                          //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// This library is free software; you can redistribute it and/or                                 //

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

//                                                                                               //

// This library 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                             //

// Lesser General Public License for more details.                                               //

//                                                                                               //

// You should have received a copy of the GNU Lesser General Public                              //

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

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

package org.distorted.library.main;

import java.util.ArrayList;

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

/**

 * This is a member of DistortedNode. Makes sure two isomorphic Nodes only get rendered once.

 */

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;

    }

  }

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

// Copyright 2016 Leszek Koltunski  leszek@koltunski.pl                                          //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// This library is free software; you can redistribute it and/or                                 //

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

//                                                                                               //

// This library 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                             //

// Lesser General Public License for more details.                                               //

//                                                                                               //

// You should have received a copy of the GNU Lesser General Public                              //

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

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

package org.distorted.library.main;

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

/**

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

 * applications!) whenever we lose OpenGL context.

 * <p>

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

*/

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;