TwistyPuzzleLib

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

// Copyright 2020 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube 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.                                                           //

//                                                                                               //

// Magic Cube 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 Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.objectlib.main;

import android.content.SharedPreferences;

import android.content.res.Resources;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

import com.google.firebase.crashlytics.FirebaseCrashlytics;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.VertexEffectQuaternion;

import org.distorted.library.effect.VertexEffectRotate;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.main.QuatHelper;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshFile;

import org.distorted.library.mesh.MeshJoined;

import org.distorted.library.mesh.MeshSquare;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.BuildConfig;

import org.distorted.objectlib.helpers.FactoryCubit;

import org.distorted.objectlib.helpers.FactorySticker;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectSticker;

import org.distorted.objectlib.helpers.ScrambleState;

import java.io.DataInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.util.Random;

import static org.distorted.objectlib.main.Movement.MOVEMENT_TETRAHEDRON;

import static org.distorted.objectlib.main.Movement.MOVEMENT_HEXAHEDRON;

import static org.distorted.objectlib.main.Movement.MOVEMENT_OCTAHEDRON;

import static org.distorted.objectlib.main.Movement.MOVEMENT_DODECAHEDRON;

import static org.distorted.objectlib.main.Movement.MOVEMENT_SHAPECHANGE;

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

public abstract class TwistyObject extends DistortedNode

  {

  public static final int COLOR_YELLOW = 0xffffff00;

  public static final int COLOR_WHITE  = 0xffffffff;

  public static final int COLOR_BLUE   = 0xff0000ff;

  public static final int COLOR_GREEN  = 0xff00bb00;

  public static final int COLOR_RED    = 0xff990000;

  public static final int COLOR_ORANGE = 0xffff6200;

  public static final int COLOR_GREY   = 0xff727c7b;

  public static final int COLOR_VIOLET = 0xff7700bb;

  public static final int COLOR_BLACK  = 0xff000000;

  public static final int TEXTURE_HEIGHT = 256;

  static final int NUM_STICKERS_IN_ROW = 4;

  public static final float SQ2 = (float)Math.sqrt(2);

  public static final float SQ3 = (float)Math.sqrt(3);

  public static final float SQ5 = (float)Math.sqrt(5);

  public static final float SQ6 = (float)Math.sqrt(6);

  private static final float MAX_SIZE_CHANGE = 1.35f;

  private static final float MIN_SIZE_CHANGE = 0.75f;

  private static final Static3D CENTER = new Static3D(0,0,0);

  private static final int POST_ROTATION_MILLISEC = 500;

  protected final int NUM_FACE_COLORS;

  protected final int NUM_TEXTURES;

  protected final Cubit[] CUBITS;

  MeshBase[] mMeshes;

  final Static4D[] OBJECT_QUATS;

  final int NUM_CUBITS;

  final int NUM_AXIS;

  final int NUM_QUATS;

  private final int mNumCubitFaces;

  private final Static3D[] mAxis;

  private final float[][] mCuts;

  private final int[] mNumCuts;

  private final int mNodeW, mNodeH;

  private final float[][] mOrigPos;

  private final Static3D mNodeScale;

  private final Static4D mQuat;

  private final int[] mNumLayers;

  private final float mSize;

  private final DistortedEffects mEffects;

  private final VertexEffectRotate mRotateEffect;

  private final Dynamic1D mRotationAngle;

  private final Static3D mRotationAxis;

  private final Static3D mObjectScale;

  private final int[] mQuatDebug;

  private final float mCameraDist;

  private final Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal;

  private final DistortedTexture mTexture;

  private final float mInitScreenRatio;

  private final int mSolvedFunctionIndex;

  private final boolean mIsBandaged;

  private float mObjectScreenRatio;

  private int[][] mSolvedQuats;

  private int[][] mQuatMult;

  private int[] mTmpQuats;

  private int mNumTexRows, mNumTexCols;

  private int mRotRowBitmap;

  private int mCurrentRotAxis;

  private MeshBase mMesh;

  private final TwistyObjectScrambler mScrambler;

  private Movement mMovement;

  private boolean[][] mLayerRotatable;

  private int[][][] mEnabled;

  //////////////////// SOLVED1 ////////////////////////

  private int[] mFaceMap;

  private int[][] mScramble;

  private int[] mColors;

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

  TwistyObject(int[] numLayers, float size, Static4D quat, Static3D move, DistortedTexture nodeTexture,

               MeshSquare nodeMesh, DistortedEffects nodeEffects, Resources res, int surfaceW, int surfaceH)

    {

    super(nodeTexture,nodeEffects,nodeMesh);

    mNodeW = surfaceW;

    mNodeH = surfaceH;

    resizeFBO(mNodeW,mNodeH);

    mNumLayers = numLayers;

    mSize = size;

    mOrigPos = getCubitPositions(mNumLayers);

    mAxis = getRotationAxis();

    mInitScreenRatio = getScreenRatio();

    mNumCubitFaces = getNumCubitFaces();

    mSolvedFunctionIndex = getSolvedFunctionIndex();

    mCuts = getCuts(mNumLayers);

    mNumCuts = new int[mAxis.length];

    for(int i=0; i<mAxis.length; i++)

      {

      mNumCuts[i] = (mCuts==null || mCuts[i]==null ? 0 : mCuts[i].length);

      }

    OBJECT_QUATS = getQuats();

    NUM_CUBITS  = mOrigPos.length;

    NUM_FACE_COLORS = getNumFaceColors();

    NUM_TEXTURES = getNumStickerTypes(mNumLayers)*NUM_FACE_COLORS;

    NUM_AXIS = mAxis.length;

    NUM_QUATS = OBJECT_QUATS.length;

    int scramblingType = getScrambleType();

    ScrambleState[] states = getScrambleStates();

    mScrambler = new TwistyObjectScrambler(scramblingType,NUM_AXIS,numLayers,states);

    boolean bandaged=false;

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

      {

      if( mOrigPos[c].length>3 )

        {

        bandaged=true;

        break;

        }

      }

    mIsBandaged = bandaged;

    mQuatDebug = new int[NUM_CUBITS];

    mNodeScale= new Static3D(surfaceW,surfaceH,surfaceW);

    mQuat = quat;

    mRotationAngle= new Dynamic1D();

    mRotationAxis = new Static3D(1,0,0);

    mRotateEffect = new VertexEffectRotate(mRotationAngle, mRotationAxis, CENTER);

    mRotationAngleStatic = new Static1D(0);

    mRotationAngleMiddle = new Static1D(0);

    mRotationAngleFinal  = new Static1D(0);

    mObjectScale = new Static3D(1,1,1);

    setObjectRatioNow(1.0f);

    MatrixEffectScale scaleEffect = new MatrixEffectScale(mObjectScale);

    MatrixEffectQuaternion quatEffect  = new MatrixEffectQuaternion(quat, CENTER);

    MatrixEffectMove moveEffect = new MatrixEffectMove(move);

    MatrixEffectScale nodeScaleEffect = new MatrixEffectScale(mNodeScale);

    nodeEffects.apply(nodeScaleEffect);

    mNumTexCols = NUM_STICKERS_IN_ROW;

    mNumTexRows = (NUM_TEXTURES+1)/NUM_STICKERS_IN_ROW;

    if( mNumTexCols*mNumTexRows < NUM_TEXTURES+1 ) mNumTexRows++;

    CUBITS = new Cubit[NUM_CUBITS];

    createMeshAndCubits(res);

    createDataStructuresForSolved(numLayers);

    mTexture = new DistortedTexture();

    mEffects = new DistortedEffects();

    createTexture();

    for(int q=0; q<NUM_QUATS; q++)

      {

      VertexEffectQuaternion vq = new VertexEffectQuaternion(OBJECT_QUATS[q],CENTER);

      vq.setMeshAssociation(0,q);

      mEffects.apply(vq);

      }

    mEffects.apply(mRotateEffect);

    mEffects.apply(quatEffect);

    mEffects.apply(scaleEffect);

    mEffects.apply(moveEffect);

    // Now postprocessed effects (the glow when you solve an object) require component centers. In

    // order for the effect to be in front of the object, we need to set the center to be behind it.

    getMesh().setComponentCenter(0,0,0,-0.1f);

    attach( new DistortedNode(mTexture,mEffects,mMesh) );

    float fov = getFOV();

    double halfFOV = fov * (Math.PI/360);

    mCameraDist = (0.5f*mNodeH) / ((float)Math.tan(halfFOV)*mNodeW);

    setProjection( fov, 0.1f);

    }

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

  private Static3D getPos(float[] origPos)

    {

    int len = origPos.length/3;

    float sumX = 0.0f;

    float sumY = 0.0f;

    float sumZ = 0.0f;

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

      {

      sumX += origPos[3*i  ];

      sumY += origPos[3*i+1];

      sumZ += origPos[3*i+2];

      }

    sumX /= len;

    sumY /= len;

    sumZ /= len;

    return new Static3D(sumX,sumY,sumZ);

    }

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

  private void createMeshAndCubits(Resources res)

    {

    int resourceID= getResource(mNumLayers);

    if( resourceID!=0 && !ObjectControl.isInCreateMesh() )

      {

      InputStream is = res.openRawResource(resourceID);

      DataInputStream dos = new DataInputStream(is);

      mMesh = new MeshFile(dos);

      try

        {

        is.close();

        }

      catch(IOException e)

        {

        android.util.Log.e("meshFile", "Error closing InputStream: "+e.toString());

        }

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

        {

        CUBITS[i] = new Cubit(this,mOrigPos[i], NUM_AXIS);

        mMesh.setEffectAssociation(i, CUBITS[i].computeAssociation(), 0);

        }

      if( shouldResetTextureMaps() ) resetAllTextureMaps();

      }

    else

      {

      MeshBase[] cubitMesh = new MeshBase[NUM_CUBITS];

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

        {

        CUBITS[i] = new Cubit(this,mOrigPos[i], NUM_AXIS);

        cubitMesh[i] = createCubitMesh(i,mNumLayers);

        Static3D pos = getPos(mOrigPos[i]);

        cubitMesh[i].apply(new MatrixEffectMove(pos),1,0);

        cubitMesh[i].setEffectAssociation(0, CUBITS[i].computeAssociation(), 0);

        }

      mMesh = new MeshJoined(cubitMesh);

      resetAllTextureMaps();

      }

    }

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

  private MeshBase createCubitMesh(int cubit, int[] numLayers)

    {

    int variant = getCubitVariant(cubit,numLayers);

    if( mMeshes==null )

      {

      FactoryCubit factory = FactoryCubit.getInstance();

      factory.clear();

      mMeshes = new MeshBase[getNumCubitVariants(numLayers)];

      }

    if( mMeshes[variant]==null )

      {

      ObjectShape shape = getObjectShape(cubit,numLayers);

      FactoryCubit factory = FactoryCubit.getInstance();

      factory.createNewFaceTransform(shape);

      mMeshes[variant] = factory.createRoundedSolid(shape);

      }

    MeshBase mesh = mMeshes[variant].copy(true);

    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( getQuat(cubit,numLayers), new Static3D(0,0,0) );

    mesh.apply(quat,0xffffffff,0);

    return mesh;

    }

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

  private void createDataStructuresForSolved(int[] numLayers)

    {

    mTmpQuats = new int[NUM_QUATS];

    mSolvedQuats = new int[NUM_CUBITS][];

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

      {

      mSolvedQuats[c] = getSolvedQuats(c,numLayers);

      }

    }

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

  private int getMultQuat(int index1, int index2)

    {

    if( mQuatMult==null )

      {

      mQuatMult = new int[NUM_QUATS][NUM_QUATS];

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

        for(int j=0; j<NUM_QUATS; j++) mQuatMult[i][j] = -1;

      }

    if( mQuatMult[index1][index2]==-1 )

      {

      mQuatMult[index1][index2] = mulQuat(index1,index2);

      }

    return mQuatMult[index1][index2];

    }

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

// This is used to build internal data structures for the generic 'isSolved()'

//

// if this is an internal cubit (all faces black): return -1

// if this is a face cubit (one non-black face): return the color index of the only non-black face.

// Color index, i.e. the index into the 'FACE_COLORS' table.

// else (edge or corner cubit, more than one non-black face): return -2.

  protected int retCubitSolvedStatus(int cubit, int[] numLayers)

    {

    int numNonBlack=0, nonBlackIndex=-1, color;

    for(int face=0; face<mNumCubitFaces; face++)

      {

      color = getFaceColor(cubit,face,numLayers);

      if( color<NUM_TEXTURES )

        {

        numNonBlack++;

        nonBlackIndex = color%NUM_FACE_COLORS;

        }

      }

    if( numNonBlack==0 ) return -1;

    if( numNonBlack>=2 ) return -2;

    return nonBlackIndex;

    }

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

  protected boolean shouldResetTextureMaps()

    {

    return false;

    }

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

  protected int[] buildSolvedQuats(Static3D faceAx, Static4D[] quats)

    {

    final float MAXD = 0.0001f;

    float x = faceAx.get0();

    float y = faceAx.get1();

    float z = faceAx.get2();

    float a,dx,dy,dz,qx,qy,qz;

    Static4D quat;

    int len = quats.length;

    int place = 0;

    for(int q=1; q<len; q++)

      {

      quat = quats[q];

      qx = quat.get0();

      qy = quat.get1();

      qz = quat.get2();

           if( x!=0.0f ) { a = qx/x; }

      else if( y!=0.0f ) { a = qy/y; }

      else               { a = qz/z; }

      dx = a*x-qx;

      dy = a*y-qy;

      dz = a*z-qz;

      if( dx>-MAXD && dx<MAXD && dy>-MAXD && dy<MAXD && dz>-MAXD && dz<MAXD )

        {

        mTmpQuats[place++] = q;

        }

      }

    if( place!=0 )

      {

      int[] ret = new int[place];

      System.arraycopy(mTmpQuats,0,ret,0,place);

      return ret;

      }

    return null;

    }

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

  private boolean isSolved0()

    {

    int len, q1,q = CUBITS[0].mQuatIndex;

    int[] solved;

    boolean skip;

    for(int c=1; c<NUM_CUBITS; c++)

      {

      q1 = CUBITS[c].mQuatIndex;

      if( q1==q ) continue;

      skip = false;

      solved = mSolvedQuats[c];

      len = solved==null ? 0:solved.length;

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

        {

        if( q1==getMultQuat(q,solved[i]) )

          {

          skip = true;

          break;

          }

        }

      if( !skip ) return false;

      }

    return true;

    }

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

  private int computeScramble(int quatNum, int centerNum)

    {

    float MAXDIFF = 0.01f;

    float[] center= mOrigPos[centerNum];

    Static4D sc = new Static4D(center[0], center[1], center[2], 1.0f);

    Static4D result = QuatHelper.rotateVectorByQuat(sc,OBJECT_QUATS[quatNum]);

    float x = result.get0();

    float y = result.get1();

    float z = result.get2();

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

      {

      float[] cent = mOrigPos[c];

      float qx = cent[0] - x;

      float qy = cent[1] - y;

      float qz = cent[2] - z;

      if( qx>-MAXDIFF && qx<MAXDIFF &&

          qy>-MAXDIFF && qy<MAXDIFF &&

          qz>-MAXDIFF && qz<MAXDIFF  ) return c;

      }

    return -1;

    }

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

// Dino4 uses this. It is solved if and only if groups of cubits

// (0,3,7), (1,2,5), (4,8,9), (6,10,11)

// or

// (0,1,4), (2,3,6), (5,9,10), (7,8,11)

// are all the same color.

  private boolean isSolved1()

    {

    if( mScramble==null )

      {

      mScramble = new int[NUM_QUATS][NUM_CUBITS];

      mColors   = new int[NUM_CUBITS];

      for(int q=0; q<NUM_QUATS; q++)

        for(int c=0; c<NUM_CUBITS; c++) mScramble[q][c] = computeScramble(q,c);

      }

    if( mFaceMap==null )

      {

      mFaceMap = new int[] { 4, 2, 2, 4, 0, 2, 1, 4, 0, 0, 1, 1 };

      }

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

      {

      int index = mScramble[CUBITS[c].mQuatIndex][c];

      mColors[index] = mFaceMap[c];

      }

    if( mColors[0]==mColors[3] && mColors[0]==mColors[7] &&

        mColors[1]==mColors[2] && mColors[1]==mColors[5] &&

        mColors[4]==mColors[8] && mColors[4]==mColors[9]  ) return true;

    if( mColors[0]==mColors[1] && mColors[0]==mColors[4] &&

        mColors[2]==mColors[3] && mColors[2]==mColors[6] &&

        mColors[5]==mColors[9] && mColors[5]==mColors[10] ) return true;

    return false;

    }

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

// Dino6 uses this. It is solved if and only if:

//

// All four 'X' cubits (i.e. those whose longest edge goes along the X axis) are rotated

// by the same quaternion qX, similarly all four 'Y' cubits by the same qY and all four 'Z'

// by the same qZ, and then either:

//

// a) qX = qY = qZ

// b) qY = qX*Q2 and qZ = qX*Q8  (i.e. swap of WHITE and YELLOW faces)

// c) qX = qY*Q2 and qZ = qY*Q10 (i.e. swap of BLUE and GREEN faces)

// d) qX = qZ*Q8 and qY = qZ*Q10 (i.e. swap of RED and BROWN faces)

//

// BUT: cases b), c) and d) are really the same - it's all just a mirror image of the original.

//

// X cubits: 0, 2, 8, 10

// Y cubits: 1, 3, 9, 11

// Z cubits: 4, 5, 6, 7

  private boolean isSolved2()

    {

    int qX = CUBITS[0].mQuatIndex;

    int qY = CUBITS[1].mQuatIndex;

    int qZ = CUBITS[4].mQuatIndex;

    if( CUBITS[2].mQuatIndex != qX || CUBITS[8].mQuatIndex != qX || CUBITS[10].mQuatIndex != qX ||

        CUBITS[3].mQuatIndex != qY || CUBITS[9].mQuatIndex != qY || CUBITS[11].mQuatIndex != qY ||

        CUBITS[5].mQuatIndex != qZ || CUBITS[6].mQuatIndex != qZ || CUBITS[ 7].mQuatIndex != qZ  )

      {

      return false;

      }

    return ( qX==qY && qX==qZ ) || ( qY==mulQuat(qX,2) && qZ==mulQuat(qX,8) );

    }

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

// Square-2 is solved iff

// a) all of its cubits are rotated with the same quat

// b) its two 'middle' cubits are rotated with the same quat, the 6 'front' and 6 'back'

// edges and corners with this quat multiplied by QUATS[18] (i.e. those are upside down)

// and all the 12 left and right edges and corners also with the same quat multiplied by

// QUATS[12] - i.e. also upside down.

  private boolean isSolved3()

    {

    int index = CUBITS[0].mQuatIndex;

    if( CUBITS[1].mQuatIndex!=index ) return false;

    boolean solved = true;

    for(int i=2; i<NUM_CUBITS; i++)

      {

      if( CUBITS[i].mQuatIndex!=index )

        {

        solved = false;

        break;

        }

      }

    if( solved ) return true;

    int indexX = mulQuat(index,12);  // QUATS[12] = 180deg (1,0,0)

    int indexZ = mulQuat(index,18);  // QUATS[18] = 180deg (0,0,1)

    for(int i= 2; i<        18; i+=2) if( CUBITS[i].mQuatIndex != indexZ ) return false;

    for(int i= 3; i<        18; i+=2) if( CUBITS[i].mQuatIndex != indexX ) return false;

    for(int i=18; i<NUM_CUBITS; i+=2) if( CUBITS[i].mQuatIndex != indexX ) return false;

    for(int i=19; i<NUM_CUBITS; i+=2) if( CUBITS[i].mQuatIndex != indexZ ) return false;

    return true;

    }

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

  int computeRow(float[] pos, int axisIndex)

    {

    int ret=0;

    int len = pos.length / 3;

    Static3D axis = mAxis[axisIndex];

    float axisX = axis.get0();

    float axisY = axis.get1();

    float axisZ = axis.get2();

    float casted;

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

      {

      casted = pos[3*i]*axisX + pos[3*i+1]*axisY + pos[3*i+2]*axisZ;

      ret |= computeSingleRow(axisIndex,casted);

      }

    return ret;

    }

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

  private int computeSingleRow(int axisIndex,float casted)

    {

    int num = mNumCuts[axisIndex];

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

      {

      if( casted<mCuts[axisIndex][i] ) return (1<<i);

      }

    return (1<<num);

    }

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

  private boolean wasRotateApplied()

    {

    return mEffects.exists(mRotateEffect.getID());

    }

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

  private boolean belongsToRotation( int cubit, int axis, int rowBitmap)

    {

    return (CUBITS[cubit].getRotRow(axis) & rowBitmap) != 0;

    }

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

// note the minus in front of the sin() - we rotate counterclockwise

// when looking towards the direction where the axis increases in values.

  private Static4D makeQuaternion(int axisIndex, int angleInDegrees)

    {

    Static3D axis = mAxis[axisIndex];

    while( angleInDegrees<0 ) angleInDegrees += 360;

    angleInDegrees %= 360;

    float cosA = (float)Math.cos(Math.PI*angleInDegrees/360);

    float sinA =-(float)Math.sqrt(1-cosA*cosA);

    return new Static4D(axis.get0()*sinA, axis.get1()*sinA, axis.get2()*sinA, cosA);

    }

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

  private synchronized void setupPosition(int[][] moves)

    {

    if( moves!=null )

      {

      Static4D quat;

      int index, axis, rowBitmap, angle;

      int[] basic = getBasicAngle();

      for(int[] move: moves)

        {

        axis     = move[0];

        rowBitmap= move[1];

        angle    = move[2]*(360/basic[axis]);

        quat     = makeQuaternion(axis,angle);

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

          if( belongsToRotation(j,axis,rowBitmap) )

            {

            index = CUBITS[j].removeRotationNow(quat);

            mMesh.setEffectAssociation(j, CUBITS[j].computeAssociation(),index);

            }

        }

      }

    }

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

  public int getScrambleType()

    {

    return 0;

    }

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

  int computeBitmapFromRow(int rowBitmap, int axis)

    {

    if( mIsBandaged )

      {

      int bitmap, initBitmap=0;

      while( initBitmap!=rowBitmap )

        {

        initBitmap = rowBitmap;

        for(int cubit=0; cubit<NUM_CUBITS; cubit++)

          {

          bitmap = CUBITS[cubit].getRotRow(axis);

          if( (rowBitmap & bitmap) != 0 ) rowBitmap |= bitmap;

          }

        }

      }

    return rowBitmap;

    }

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

// Clamp all rotated positions to one of those original ones to avoid accumulating errors.

// Do so only if minimal Error is appropriately low (shape-shifting puzzles - Square-1)

  void clampPos(float[] pos, int offset)

    {

    float currError, minError = Float.MAX_VALUE;

    int minErrorIndex1 = -1;

    int minErrorIndex2 = -1;

    float x = pos[offset  ];

    float y = pos[offset+1];

    float z = pos[offset+2];

    float xo,yo,zo;

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

      {

      int len = mOrigPos[i].length / 3;

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

        {

        xo = mOrigPos[i][3*j  ];

        yo = mOrigPos[i][3*j+1];

        zo = mOrigPos[i][3*j+2];

        currError = (xo-x)*(xo-x) + (yo-y)*(yo-y) + (zo-z)*(zo-z);

        if( currError<minError )

          {

          minError = currError;

          minErrorIndex1 = i;

          minErrorIndex2 = j;

          }

        }

      }

    if( minError< 0.1f ) // TODO: 0.1 ?

      {

      pos[offset  ] = mOrigPos[minErrorIndex1][3*minErrorIndex2  ];

      pos[offset+1] = mOrigPos[minErrorIndex1][3*minErrorIndex2+1];