Distorted Android

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

// Copyright 2020 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.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;

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

/**

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

  private static final int JOB_TYPE_CENTER       = 8;

  private static final int JOB_TYPE_ADD_EMPTY_TEX= 9;

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

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

  private static class Job

    {

    private final int mType;

    private final MeshBase mTarget;

    private final MeshBase[] mSource;

    private final MatrixEffect mMatrixEffect;

    private final Static4D[] mMaps;

    private final int mComp, mAndAssoc, mEquAssoc;

    private final float mX,mY,mZ;

    private EffectQueueVertex mVertexEffects;

    Job(int type, MeshBase target, MeshBase[] source, VertexEffect vEff, MatrixEffect mEff,

        Static4D[] maps, int comp, int and, int equ, float x, float y, float z)

      {

      mType     = type;

      mTarget   = target;

      mSource   = source;

      mMaps     = maps;

      mComp     = comp;

      mAndAssoc = and;

      mEquAssoc = equ;

      mX        = x;

      mY        = y;

      mZ        = z;

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

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

                                     break;

        case JOB_TYPE_ASSOC        : mTarget.setEffectAssociationNow(mComp,mAndAssoc,mEquAssoc);

                                     break;

        case JOB_TYPE_CENTER       : mTarget.setComponentCenterNow(mComp,mX,mY,mZ);

                                     break;

        case JOB_TYPE_ADD_EMPTY_TEX: mTarget.addEmptyTexComponentNow();

                                     break;

        }

      }

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

        case JOB_TYPE_ASSOC        : return "ASSOC";

        case JOB_TYPE_CENTER       : return "CENTER";

        case JOB_TYPE_ADD_EMPTY_TEX: return "ADD_EMPTY_TEX";

        }

      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;

      }

    synchronized void execute()

      {

      if( mPrevJobs!=null )

        {

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

        }

      }

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

      DistortedLibrary.logMessage("DeferredJobs: "+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,0,0,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,0,0,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,0,andAssoc,ecuAssoc,0,0,0);

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

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode addEmptyTex(MeshBase target)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_ADD_EMPTY_TEX,target,null,null,null,null,0,0,0,0,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,0,0,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,0,0,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,0,0,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, int comp)

    {

    JobNode jn = target.mJobNode[0];

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

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode effectAssoc(MeshBase target, int comp, int andAssoc, int equAssoc)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_ASSOC,target,null,null,null,null,comp,andAssoc,equAssoc,0,0,0);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode componentCenter(MeshBase target, int comp, float x, float y, float z)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_CENTER,target,null,null,null,null,comp,0,0,x,y,z);

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

    {

    int num = mJobs.size();

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

      {

      mJobs.get(i).clear();

      }

    mJobs.clear();

    }

  }