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.MatrixEffect;

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_MATRIX   = 1;

  private static final int JOB_TYPE_MERGE_TEX= 2;

  private static final int JOB_TYPE_MERGE_EFF= 3;

  private static final int JOB_TYPE_JOIN     = 4;

  private static final int JOB_TYPE_COPY     = 5;

  private static final int JOB_TYPE_TEXTURE  = 6;

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

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

  private static class Job

    {

    private int mType;

    private MeshBase mTarget;

    private MeshBase[] mSource;

    private EffectQueueVertex mVertexEffects;

    private MatrixEffect mMatrixEffect;

    private Static4D[] mMaps;

    private int mAndAssoc, mEcuAssoc;

    Job(int type, MeshBase target, MeshBase[] source, VertexEffect vEff, MatrixEffect mEff, Static4D[] maps, int and, int ecu)

      {

      mType     = type;

      mTarget   = target;

      mSource   = source;

      mMaps     = maps;

      mAndAssoc = and;

      mEcuAssoc = ecu;

      if( vEff!=null )

        {

        mVertexEffects= new EffectQueueVertex();

        mVertexEffects.add(vEff);

        }

      mMatrixEffect = mEff;

      }

    void addEffect(VertexEffect effect)

      {

      mVertexEffects.add(effect);

      }

    void execute()

      {

      switch(mType)

        {

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

                                 break;

        case JOB_TYPE_MATRIX   : mTarget.applyMatrix(mMatrixEffect,mAndAssoc,mEcuAssoc);

                                 break;

        case JOB_TYPE_MERGE_TEX: mTarget.mergeTexComponentsNow();

                                 break;

        case JOB_TYPE_MERGE_EFF: mTarget.mergeEffComponentsNow();

                                 break;

        case JOB_TYPE_JOIN     : mTarget.joinAttribs(mSource);

                                 break;

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

                                 break;

        case JOB_TYPE_TEXTURE  : mTarget.textureMap(mMaps);

                                 break;

        }

/*

      Log.e("jobs", "executing "+print()+" job");

      mTarget.print();

*/

      }

    void clear()

      {

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

      }

    String print()

      {

      switch(mType)

        {

        case JOB_TYPE_VERTEX   : return "VERTEX";

        case JOB_TYPE_MATRIX   : return "MATRIX";

        case JOB_TYPE_MERGE_TEX: return "MERGE_TEX";

        case JOB_TYPE_MERGE_EFF: return "MERGE_EFF";

        case JOB_TYPE_JOIN     : return "JOIN";

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

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

        JobNode node = new JobNode(job);

        node.mPrevJobs.add(jn);

        jn.mNextJobs.add(node);

        mJobs.add(node);

        return node;

        }

      }

    }

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

  static JobNode matrix(MeshBase target, MatrixEffect effect, int andAssoc, int ecuAssoc)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_MATRIX,target,null,null,effect,null,andAssoc,ecuAssoc);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode mergeTex(MeshBase target)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_MERGE_TEX,target,null,null,null,null,0,0);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode mergeEff(MeshBase target)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_MERGE_EFF,target,null,null,null,null,0,0);

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

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

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

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

    }

  }