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 org.distorted.library.type.Static4D;

import java.util.ArrayList;

import android.util.Log;

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

/**

 * 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 final int JOB_TYPE_TEXTURE= 4;

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

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

  private static class Job

    {

    private int mType;

    private MeshBase mTarget;

    private MeshBase[] mSource;

    private EffectQueueVertex mEffects;

    private Static4D[] mMaps;

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

      {

      mType   = type;

      mTarget = target;

      mSource = source;

      mMaps   = maps;

      if( effect!=null )

        {

        mEffects= new EffectQueueVertex();

        mEffects.add(effect);

        }

      }

    void addEffect(VertexEffect effect)

      {

      mEffects.add(effect);

      }

    void execute()

      {

      switch(mType)

        {

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

                               //Log.e("jobs", "executing vertex job");

                               //mTarget.print();

                               break;

        case JOB_TYPE_MERGE  : mTarget.merge();

                               //Log.e("jobs", "executing merge job");

                               //mTarget.print();

                               break;

        case JOB_TYPE_JOIN   : mTarget.joinAttribs(mSource);

                               //Log.e("jobs", "executing join job");

                               //mTarget.print();

                               break;

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

                               //Log.e("jobs", "executing copy job");

                               //mTarget.print();

                               break;

        case JOB_TYPE_TEXTURE: mTarget.textureMap(mMaps);

                               //Log.e("jobs", "executing textureMap job");

                               //mTarget.print();

                               break;

        }

      }

    void clear()

      {

      if( mEffects!=null ) mEffects.removeAll(false);

      }

    String print()

      {

      switch(mType)

        {

        case JOB_TYPE_VERTEX : return "VERTEX (eff: "+mEffects.getNumEffects()+" effToBe: "+mEffects.getNumEffectsToBe()+")";

        case JOB_TYPE_MERGE  : return "MERGE";

        case JOB_TYPE_JOIN   : return "JOIN: "+mSource.length;

        case JOB_TYPE_COPY   : return "COPY";

        case JOB_TYPE_TEXTURE: return "TEXTURE";

        }

      return null;

      }

    }

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

  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;

      }

    void execute()

      {

      JobNode node;

      int numPrev = mPrevJobs.size();

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

        {

        node = mPrevJobs.get(0);  // removeNode() rips the executed job out, thus the 0

        node.execute();

        }

      removeNode(this);

      mJob.execute();

      }

    void clear()

      {

      mPrevJobs.clear();

      mPrevJobs = null;

      mNextJobs.clear();

      mNextJobs = null;

      mJob.clear();

      mJob = null;

      }

    void print(int level)

      {

      int numPrev = mPrevJobs.size();

      int numNext = mNextJobs.size();

      String str = "";

      for(int i=0; i<level; i++) str+=" ";

      str += mJob.print();

      str += (" next: "+numNext+" prev: "+numPrev);

      Log.e("job", str);

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

        {

        JobNode node = mPrevJobs.get(i);

        node.print(level+1);

        }

      }

    }

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

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

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

        JobNode node = new JobNode(job);

        node.mPrevJobs.add(jn);

        jn.mNextJobs.add(node);

        mJobs.add(node);

        return node;

        }

      }

    }

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

  static JobNode merge(MeshBase target)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_MERGE,target,null,null,null);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

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

    {

    JobNode jn;

    Job job = new Job(JOB_TYPE_JOIN,target,meshes,null,null);

    JobNode node = new JobNode(job);

    for (MeshBase mesh : meshes)

      {

      jn = mesh.mJobNode[0];

      if( jn!=null )

        {

        node.mPrevJobs.add(jn);

        jn.mNextJobs.add(node);

        }

      }

    mJobs.add(node);

    return node;

    }

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

  static JobNode copy(MeshBase target, MeshBase mesh)

    {

    JobNode jn = mesh.mJobNode[0];

    MeshBase[] meshes = new MeshBase[1];

    meshes[0] = mesh;

    Job job = new Job(JOB_TYPE_COPY,target,meshes,null,null);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode textureMap(MeshBase target, Static4D[] maps)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_TEXTURE,target,null,null,maps);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

/**

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

    }

  }