Distorted Android

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

// 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.mesh;

import org.distorted.library.effect.VertexEffect;

import org.distorted.library.effectqueue.EffectQueueVertex;

import org.distorted.library.main.DistortedLibrary;

import java.util.ArrayList;

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

/**

 * Not part of public API, do not document (public only because has to be cleaned from the main package)

 *

 * @y.exclude

 */

public class DeferredJobs

  {

  private static final int JOB_TYPE_VERTEX = 0;

  private static final int JOB_TYPE_MERGE  = 1;

  private static final int JOB_TYPE_JOIN   = 2;

  private static final int JOB_TYPE_COPY   = 3;

  private static ArrayList<JobNode> mJobs = new ArrayList<>();

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

  private static class Job

    {

    private int mType;

    private MeshBase mTarget;

    private MeshBase[] mSource;

    private EffectQueueVertex mEffects;

    Job(int type, MeshBase target, MeshBase[] source, VertexEffect effect)

      {

      mType   = type;

      mTarget = target;

      mSource = source;

      mEffects= new EffectQueueVertex();

      mEffects.add(effect);

      }

    Job(Job job)

      {

      mType   = job.mType;

      mTarget = job.mTarget;

      mSource = job.mSource;

      mEffects= new EffectQueueVertex(job.mEffects);

      }

    void addEffect(VertexEffect effect)

      {

      mEffects.add(effect);

      }

    void execute()

      {

      switch(mType)

        {

        case JOB_TYPE_VERTEX: DistortedLibrary.adjustVertices(mTarget, mEffects);

                              break;

        case JOB_TYPE_MERGE : break;

        case JOB_TYPE_JOIN  : break;

        case JOB_TYPE_COPY  : mTarget.deepCopyAttribs1(mSource[0]);

                              break;

        }

      }

    void clear()

      {

      mEffects.removeAll(false);

      }

    }

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

  static class JobNode

    {

    private ArrayList<JobNode> mPrevJobs;

    private ArrayList<JobNode> mNextJobs;

    private Job mJob;

    JobNode(Job job)

      {

      mPrevJobs = new ArrayList<>();

      mNextJobs = new ArrayList<>();

      mJob      = job;

      }

    JobNode(JobNode node)

      {

      mPrevJobs = new ArrayList<>();

      mNextJobs = new ArrayList<>();

      mJob      = new Job(node.mJob);

      int numPrev = node.mPrevJobs.size();

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

        {

        mPrevJobs.add(node.mPrevJobs.get(i));

        }

      int numNext = node.mNextJobs.size();

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

        {

        mNextJobs.add(node.mNextJobs.get(i));

        }

      }

    void execute()

      {

      JobNode node;

      int numPrev = mPrevJobs.size();

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

        {

        node = mPrevJobs.get(i);

        node.execute();

        }

      removeNode(this);

      mJob.execute();

      }

    void clear()

      {

      mPrevJobs.clear();

      mPrevJobs = null;

      mNextJobs.clear();

      mNextJobs = null;

      mJob.clear();

      mJob = null;

      }

    }

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

  private static void removeNode(JobNode node)

    {

    mJobs.remove(node);

    JobNode jn;

    int numPrev = node.mPrevJobs.size();

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

      {

      jn = node.mPrevJobs.get(i);

      jn.mNextJobs.remove(node);

      }

    int numNext = node.mNextJobs.size();

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

      {

      jn = node.mNextJobs.get(i);

      jn.mPrevJobs.remove(node);

      }

    node.mJob.mTarget.mJobNode[0] = null;

    }

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

  static JobNode vertex(MeshBase target, VertexEffect effect)

    {

    JobNode jn = target.mJobNode[0];

    if( jn==null )

      {

      Job job = new Job(JOB_TYPE_VERTEX,target,null,effect);

      JobNode node = new JobNode(job);

      mJobs.add(node);

      return node;

      }

    else

      {

      if( jn.mJob.mType==JOB_TYPE_VERTEX )

        {

        jn.mJob.addEffect(effect);

        return jn;

        }

      else

        {

        Job job = new Job(JOB_TYPE_VERTEX,target,null,effect);

        JobNode node = new JobNode(job);

        node.mPrevJobs.add(jn);

        jn.mNextJobs.add(node);

        mJobs.add(node);

        return node;

        }

      }

    }

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

  static JobNode merge(MeshBase target)

    {

    return null;

    }

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

  static JobNode join(MeshBase target, MeshBase[] meshes)

    {

    return null;

    }

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

  static JobNode copy(MeshBase target, MeshBase mesh)

    {

    return null;

    }

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

/**

 * Only for use by the library itself.

 *

 * @y.exclude

 */

  public static void onDestroy()

    {

    int num = mJobs.size();

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

      {

      mJobs.get(i).clear();

      }

    mJobs.clear();

    }

  }