Distorted Android

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

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

      }

    }

  }