TwistyPuzzleLib

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

// Copyright 2023 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.objectlib.bandaged;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

import org.distorted.library.helpers.QuatHelper;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.FactoryCubit;

import org.distorted.objectlib.main.TwistyObject;

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

public abstract class BandagedObject

{

    private static final float[] mTmp = new float[4];

    private final DistortedScreen mScreen;

    private final float[][] mFaceAxis;

    private BandagedCubit[] mCubits;

    private final float[][] mRotAxis;

    private Bitmap mBitmap;

    private Static4D[] mTextureMaps;

    float[][] mCuts;

    final int[] mSize;

    final float mDist2D;

    int mMax;

    int mNumCubits;

    int mMinSize, mMaxSize;

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

   BandagedObject(DistortedScreen screen, int minSize, int maxSize)

     {

     mScreen = screen;

     mRotAxis = getRotAxis();

     mDist2D = getDist2D();

     Static3D[] axis = getFaceAxis();

     int numAxis = axis.length;

     mFaceAxis = new float[numAxis][];

     for(int i=0; i<numAxis; i++) mFaceAxis[i] = new float[] { axis[i].get0(), axis[i].get1(), axis[i].get2() };

     int numRot= mRotAxis.length;

     mSize = new int[numRot];

     for(int a=0; a<numRot; a++) mSize[a] = minSize;

     mMinSize = minSize;

     mMaxSize = maxSize;

     }

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

   abstract float[][] getRotAxis();

   abstract float getDist2D();

   abstract int[] getColors();

   abstract float[][][] getPositions();

   abstract boolean isAdjacent(float x1, float y1, float z1, float x2, float y2, float z2 );

   abstract MeshBase createMesh(float[] pos, boolean round);

   public abstract TwistyObject createObject(int mode, float scale );

   public abstract float[] getDist3D();

   public abstract int computeProjectionAngle();

   public abstract boolean tryChangeObject(int x, int y, int z);

   public abstract boolean isInsideFace(int face, float[] p);

   public abstract Static3D[] getFaceAxis();

   public abstract float getScreenRatio();

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

  private void createBitmap(int[] colors)

    {

    final int NUM = colors.length;

    final int SIZE= 32;

    mTextureMaps = new Static4D[NUM];

    Paint paint = new Paint();

    paint.setStyle(Paint.Style.FILL);

    mBitmap = Bitmap.createBitmap( NUM*SIZE, SIZE, Bitmap.Config.ARGB_4444);

    Canvas canvas = new Canvas(mBitmap);

    for(int color=0; color<NUM; color++)

      {

      paint.setColor(colors[color]);

      canvas.drawRect(color*SIZE, 0, (color+1)*SIZE, SIZE, paint);

      mTextureMaps[color] = new Static4D( ((float)color)/NUM, 0.0f, 1.0f/NUM, 1.0f );

      }

    }

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

  void resetTextureMaps(MeshBase mesh)

    {

    FactoryCubit fact = FactoryCubit.getInstance();

    int numComponents = mesh.getNumTexComponents();

    Static4D[] maps = new Static4D[numComponents];

    if( mTextureMaps==null || mBitmap==null )

      {

      createBitmap(getColors());

      }

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

      {

      Static4D q = fact.getQuaternion(i);

      QuatHelper.rotateVectorByQuat(mTmp,0,0,1,0,q);

      int index = computeMapsIndex(mTmp);

      maps[i] = mTextureMaps[index];

      }

    mesh.setTextureMap(maps,0);

    }

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

  private float getRotRow(int ax, float d)

    {

    float[] cuts = mCuts[ax];

    int numCuts = cuts==null ? 0 : cuts.length;

    for(int c=0; c<numCuts; c++) if( d<=cuts[c] ) return c;

    return numCuts;

    }

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

  float[][] getRotRows(float[] pos)

    {

    int num = pos.length/3;

    int numAx = mRotAxis.length;

    float[][] ret = new float[num][numAx];

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

      for(int a=0; a<numAx; a++)

        {

        float[] ax = mRotAxis[a];

        float x = pos[3*p];

        float y = pos[3*p+1];

        float z = pos[3*p+2];

        float d = ax[0]*x + ax[1]*y + ax[2]*z;

        ret[p][a] = getRotRow(a,d);

        }

    return ret;

    }

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

  public void createCubits(Static4D quatT, Static4D quatA, Static3D scale)

    {

    mCubits = new BandagedCubit[mNumCubits];

    float[][][] pos = getPositions();

    int c=0;

    for(float[][] po : pos)

      for(float[] p : po)

        mCubits[c++] = new BandagedCubit(this, p, quatT, quatA, scale, false);

    }

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

  int computeMapsIndex(float[] faceAx)

    {

    int min=-1, numAxis = mFaceAxis.length;

    float error = Float.MAX_VALUE;

    float x = faceAx[0];

    float y = faceAx[1];

    float z = faceAx[2];

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

      {

      float[] ax = mFaceAxis[i];

      float dx = x-ax[0];

      float dy = y-ax[1];

      float dz = z-ax[2];

      float diff = dx*dx + dy*dy + dz*dz;

      if( error>diff )

        {

        error = diff;

        min = i;

        }

      }

    return min;

    }

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

  public void resetObject(float scale)

    {

    for(int c=0; c<mNumCubits; c++)

      {

      if( !mCubits[c].isAttached() )

        {

        mCubits[c].attach();

        mScreen.attach(mCubits[c].getNode());

        }

      if( mCubits[c].getPosition().length>3 )

        {

        mCubits[c].reset(scale);

        }

      mCubits[c].setUnmarked();

      }

    }

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

  public float getMaxSize()

    {

    return mMax;

    }

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

  float[][] getCubitPositions()

    {

    int numAttached = 0;

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

      if( mCubits[i].isAttached() ) numAttached++;

    float[][] pos = new float[numAttached][];

    int attached=0;

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

      if( mCubits[i].isAttached() )

        pos[attached++] = mCubits[i].getPosition();

    return pos;

    }

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

  public void tryConnectingCubits(int index1, int index2, float scale)

    {

    if( index1!=index2 )

      {

      float[] pos1 = mCubits[index1].getPosition();

      float[] pos2 = mCubits[index2].getPosition();

      if( isAdjacent(pos1,pos2) )

        {

        mCubits[index2].join(pos1,scale);

        mCubits[index1].detach();

        mScreen.detach(mCubits[index1].getNode());

        }

      }

    }

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

  public void attachCubits(float scale)

    {

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

      {

      mCubits[i].scaleMove(scale);

      DistortedNode node = mCubits[i].getNode();

      mScreen.attach(node);

      }

    }

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

  public void attachAndMarkCubits(float scale, int touched)

    {

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

      {

      if( mCubits[i].isAttached() )

        {

        mCubits[i].scaleMove(scale);

        if( touched==i ) mCubits[i].setMarked();

        else             mCubits[i].setUnmarked();

        DistortedNode node = mCubits[i].getNode();

        mScreen.attach(node);

        }

      }

    }

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

  public void scaleCubits(float scale)

    {

    for(int i=0; i<mNumCubits; i++) mCubits[i].scaleMove(scale);

    }

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

  public void recreateCubits(Static4D quatT, Static4D quatA, Static3D scale)

    {

    if( mCubits==null )

      {

      createCubits(quatT,quatA,scale);

      }

    else

      {

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

        {

        DistortedTexture tex = mCubits[i].getTexture();

        recreateBitmap(tex);

        }

      }

    }

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

  void recreateBitmap(DistortedTexture tex)

    {

    if( mBitmap==null ) createBitmap(getColors());

    tex.setTextureAlreadyInverted(mBitmap);

    }

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

  public void touchCubit(int index)

    {

    if( index>=0 && index<mNumCubits && mCubits[index]!=null ) mCubits[index].setMarked();

    }

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

  public void untouchCubit(int index)

    {

    if( index>=0 && index<mNumCubits && mCubits[index]!=null ) mCubits[index].setUnmarked();

    }

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

  public int whichCubitTouched(float[] point3D)

    {

    float x = point3D[0]*mMax;

    float y = point3D[1]*mMax;

    float z = point3D[2]*mMax;

    int numAxis = mRotAxis.length;

    float[] rotRow = new float[numAxis];

    for(int a=0; a<numAxis; a++)

      {

      float[] ax = mRotAxis[a];

      float d = ax[0]*x + ax[1]*y + ax[2]*z;

      rotRow[a] = getRotRow(a,d);

      }

    int diff = Integer.MAX_VALUE;

    int currBest = -1;

    for(int c=0; c<mNumCubits; c++)

      if( mCubits[c].isAttached() )

        {

        float[][] cubitRotRow = mCubits[c].getRotRow();

        for(float[] row : cubitRotRow)

          {

          int currDiff = 0;

          for(int a=0; a<numAxis; a++)

            {

            float d = rotRow[a]-row[a];

            currDiff += d*d;

            }

          if( currDiff<diff )

            {

            diff = currDiff;

            currBest = c;

            }

          }

        }

    return currBest;

    }

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

  boolean isAdjacent(float[] pos1, float[] pos2)

     {

     int len1 = pos1.length/3;

     int len2 = pos2.length/3;

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

       {

       float x1 = pos1[3*i  ];

       float y1 = pos1[3*i+1];

       float z1 = pos1[3*i+2];

       for(int j=0; j<len2; j++)

         {

         float x2 = pos2[3*j  ];

         float y2 = pos2[3*j+1];

         float z2 = pos2[3*j+2];

         if( isAdjacent(x1,y1,z1,x2,y2,z2) ) return true;

         }

       }

     return false;

     }

}