TwistyPuzzleLib

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

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

import java.io.DataInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.util.Random;

import android.content.SharedPreferences;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

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.effect.VertexEffectSink;

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.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.helpers.FactoryCubit;

import org.distorted.objectlib.helpers.FactorySticker;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectLibInterface;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectSignature;

import org.distorted.objectlib.helpers.ObjectSticker;

import org.distorted.objectlib.helpers.ObjectStickerOverride;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.helpers.QuatGroupGenerator;

import org.distorted.objectlib.scrambling.ObjectScrambler;

import org.distorted.objectlib.json.JsonReader;

import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;

import org.distorted.objectlib.touchcontrol.*;

import static org.distorted.objectlib.touchcontrol.TouchControl.*;

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

public abstract class TwistyObject

  {

  public static final int MESH_NICE = 0;

  public static final int MESH_FAST = 1;

  public static final int MODE_ICON = 0;

  public static final int MODE_NORM = 1;

  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_STROKE   = 0xff000000;

  public static final int COLOR_INTERNAL = 0xff000000;

  private static final int STATE_NOTHING = 0;

  private static final int STATE_ROTATE  = 1;

  private static final int STATE_FINISH  = 2;

  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 float[][] mStickerCoords;

  protected Static4D[] mObjectQuats;

  private int[][] mStickerVariants;

  private float[] mStickerScales;

  private TwistyObjectCubit[] mCubits;

  private TwistyObjectSolved mSolved;

  private MeshBase[] mMeshes;

  private int mNumCubits, mNumQuats, mNumFaceColors, mNumTextures, mNumOverrides;

  private int mNumCubitFaces, mNumStickerTypes;

  private Static3D[] mAxis;

  private float[][] mCuts;

  private int[] mNumCuts;

  private float[][] mOrigPos;

  private Static4D[] mOrigQuat;

  private Static4D[] mMixupModeQuats;

  private boolean mIsInMixupMode;

  private Static4D mQuat;

  private int[] mNumLayers;

  private float mSize;

  private DistortedEffects mEffects;

  private VertexEffectRotate mRotateEffect;

  private Dynamic1D mRotationAngle;

  private Static3D mRotationAxis;

  private Static3D mObjectScale;

  private int[] mQuatDebug;

  private Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal;

  private DistortedTexture mTexture;

  private float mInitScreenRatio;

  private boolean mIsBandaged;

  private float mObjectScreenRatio;

  private int mNumTexRows, mNumTexCols;

  private int mRotRowBitmap;

  private int mCurrentRotAxis;

  private MeshBase mMesh;

  private ObjectScrambler mScrambler;

  private TouchControl mTouchControl;

  private DistortedNode mNode;

  private ObjectLibInterface mInterface;

  private Bitmap mBitmap;

  private ObjectSticker[] mStickers;

  private ObjectShape[] mShapes;

  private int mNumCubitVariants;

  private int[][] mCubitFaceColors;

  private int[][] mVariantFaceIsOuter;

  private int[][] mBasicAngles;

  private int mIconMode;

  private InitData mInitData;

  private float[][] mRowOffsets;

  private boolean[] mBelongs;

  private float[] mTmp;

  private int mNumPuzzleFaces;

  private ObjectStickerOverride[] mStickerOverrides;

  private boolean mError;

  private String mErrorString;

  private int mMaxNumLayers;

  private int mNumAxis;

  private int mPointNum;

  private int mRotationState;

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

  TwistyObject(InputStream jsonStream, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream meshStream)

    {

    try

      {

      JsonReader reader = new JsonReader();

      reader.parseJsonFile(jsonStream);

      setReader(reader);

      mNumLayers = reader.getNumLayers();

      mSize      = reader.getSize();

      mInitData  = null;

      initialize(meshState,iconMode,quat,move,scale,meshStream,true);

      mError = false;

      mErrorString=null;

      }

    catch(Exception ex)

      {

      mError = true;

      mErrorString = ex.getMessage();

      }

    }

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

  public TwistyObject(InitData data, int meshState, int iconMode, float size, Static4D quat, Static3D move, float scale, InputStream meshStream)

    {

    mNumLayers = data.getNumLayers();

    mSize      = size;

    mInitData  = data;

    initialize(meshState,iconMode,quat,move,scale,meshStream,false);

    mError = false;

    mErrorString = null;

    }

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

  private void debugQuat(Static4D quat, int cubitIndex, float axisX, float axisY, float axisZ, float angle, int place)

    {

    float[] tracking = mCubits[cubitIndex].getTrackingPoint();

    String problem = (getShortName()+" "+cubitIndex+" "+quat.get0()+" "+quat.get1()+" "+quat.get2()+" "+quat.get3());

    problem += (" "+angle+" "+place+" "+tracking[0]+" "+tracking[1]+" "+tracking[2]);

    problem += (" "+axisX+" "+axisY+" "+axisZ)+" "+mPointNum;

    mInterface.reportProblem(problem,true);

    }

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

  private void initialize(int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream meshStream, boolean fromJSON)

    {

    mRotationState = STATE_NOTHING;

    mIconMode = iconMode;

    mQuat = quat;

    mAxis = getRotationAxis();

    mInitScreenRatio = getScreenRatio();

    mBasicAngles = getBasicAngles();

    mObjectQuats = getQuats();

    mNumQuats = mObjectQuats.length;

    mOrigPos = getCubitPositions(mNumLayers);

    mNumPuzzleFaces = getNumFaces();

    mRowOffsets = new float[mNumPuzzleFaces][3];

    mTmp = new float[4];

    mNumAxis = mAxis.length;

    mCuts = getCuts(mNumLayers);

    mNumCuts = new int[mNumAxis];

    mMaxNumLayers = -1;

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

      {

      if( mMaxNumLayers<mNumLayers[i] ) mMaxNumLayers = mNumLayers[i];

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

      }

    mNumCubits = mOrigPos.length;

    mNumFaceColors = getNumFaceColors();

    mBelongs = new boolean[mNumCubits];

    int scramblingType = getScrambleType();

    int[][] edges = getScrambleEdges();

    int[][] algorithms = getScrambleAlgorithms();

    mScrambler = new ObjectScrambler(scramblingType,mNumAxis,mNumLayers,algorithms,edges);

    boolean bandaged=false;

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

      {

      if( mOrigPos[c].length>3 )

        {

        bandaged=true;

        break;

        }

      }

    mIsBandaged = bandaged;

    mQuatDebug = new int[mNumCubits];

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

    setObjectRatioNow(scale,720);

    mEffects = new DistortedEffects();

    createQuaternionEffects();

    MatrixEffectScale scaleEffect = new MatrixEffectScale(mObjectScale);

    MatrixEffectQuaternion quatEffect = new MatrixEffectQuaternion(mQuat, CENTER);

    MatrixEffectMove moveEffect = new MatrixEffectMove(move);

    boolean fromDMESH = (meshStream!=null && meshState==MESH_NICE);

    getQuatsAndShapes(fromDMESH,fromJSON);

    createMeshAndCubits(meshStream,meshState,fromDMESH);

    setUpTextures(fromDMESH,fromJSON);

    int index = getSolvedFunctionIndex();

    mSolved = new TwistyObjectSolved(this,mOrigPos,index);

    mSolved.setupSolvedQuats(getSolvedQuats());

    mEffects.apply(mRotateEffect);

    mEffects.apply(quatEffect);

    mEffects.apply(scaleEffect);

    mEffects.apply(moveEffect);

    mNode = new DistortedNode(mTexture,mEffects,mMesh);

    }

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

  private void createQuaternionEffects()

    {

    if( mNumQuats<=ObjectControl.MAX_QUATS )

      {

      mIsInMixupMode = false;

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

        {

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

        vq.setMeshAssociation(0,q);

        mEffects.apply(vq);

        }

      }

    else if( mNumCubits<=ObjectControl.MAX_QUATS )

      {

      mIsInMixupMode = true;

      mMixupModeQuats = new Static4D[mNumCubits];

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

        {

        mMixupModeQuats[q] = new Static4D(mObjectQuats[0]);

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

        vq.setMeshAssociation(0,q);

        mEffects.apply(vq);

        }

      }

    else

      {

      android.util.Log.e("D", "object has too many quaternions ("+mNumQuats+") or too many cubits ("+mNumCubits+")");

      }

    }

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

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

    {

    for(int v=0; v<mNumCubitVariants; v++)

      {

      int[][] indices = mShapes[v].getVertIndices();

      int faces = indices.length;

      mVariantFaceIsOuter[v] = new int[faces];

      }

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

      {

      int variant = getCubitVariant(cubit,mNumLayers);

      int[][] indices = mShapes[variant].getVertIndices();

      int numFaces = indices.length;

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

        if( getCubitFaceColor(cubit,face)>=0 )

          {

          mVariantFaceIsOuter[variant][face] = 1;

          }

      }

    }

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

  private void getQuatsAndShapes(boolean fromDMESH, boolean fromJSON)

    {

    mNumCubitVariants = getNumCubitVariants(mNumLayers);

    if( !fromDMESH || !fromJSON )

      {

      FactoryCubit factory = FactoryCubit.getInstance();

      factory.clear();

      mOrigQuat = new Static4D[mNumCubits];

      for(int i=0; i<mNumCubits; i++) mOrigQuat[i] = getCubitQuats(i,mNumLayers);

      mShapes = new ObjectShape[mNumCubitVariants];

      for(int i=0; i<mNumCubitVariants; i++) mShapes[i] = getObjectShape(i);

      mNumCubitFaces = ObjectShape.computeNumComponents(mShapes);

      mVariantFaceIsOuter = new int[mNumCubitVariants][];

      if( !fromJSON )

        {

        mCubitFaceColors = ObjectShape.computeColors(mShapes,mOrigPos,mOrigQuat,this);

        createOuterFaces();

        }

      if( fromDMESH )

        {

        for(int i=0; i<mNumCubitVariants; i++) factory.createNewFaceTransform(mShapes[i], mVariantFaceIsOuter[i]);

        }

      }

    }

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

  private void createMeshAndCubits(InputStream stream, int meshState, boolean fromDMESH)

    {

    mCubits = new TwistyObjectCubit[mNumCubits];

    if( fromDMESH )

      {

      DataInputStream dos = new DataInputStream(stream);

      mMesh = new MeshFile(dos);

      try

        {

        stream.close();

        }

      catch(IOException e)

        {

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

        }

      }

    else

      {

      MeshBase[] cubitMesh = new MeshBase[mNumCubits];

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

        {

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

        Static3D pos = getPos(mOrigPos[i]);

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

        }

      mMesh = new MeshJoined(cubitMesh);

      float pillowCoeff = getPillowCoeff();

      if( pillowCoeff!=1.0f )

        {

        float radius = getCircumscribedRadius();

        Static1D coeff = new Static1D(pillowCoeff);

        Static4D region= new Static4D(0,0,0,radius);

        VertexEffectSink sink = new VertexEffectSink(coeff,CENTER,region);

        mMesh.apply(sink);

        }

      }

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

      {

      mCubits[i] = new TwistyObjectCubit(this,mOrigPos[i],mNumAxis,mMaxNumLayers,i);

      setCubitQuat(i,mCubits[i].computeAssociation(),0);

      }

    }

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

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

    {

    int variant = getCubitVariant(cubit,numLayers);

    if( mMeshes==null ) mMeshes = new MeshBase[mNumCubitVariants];

    if( mMeshes[variant]==null )

      {

      ObjectFaceShape faceShape = getObjectFaceShape(variant);

      ObjectVertexEffects effects = getVertexEffects(variant);

      FactoryCubit factory = FactoryCubit.getInstance();

      factory.createNewFaceTransform(mShapes[variant],mVariantFaceIsOuter[variant]);

      mMeshes[variant] = factory.createRoundedSolid(mShapes[variant],faceShape,effects, meshState, numComponents);

      }

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

    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( mOrigQuat[cubit], CENTER );

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

    return mesh;

    }

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

  private void setUpTextures(boolean fromDMESH, boolean fromJSON)

    {

    mTexture = new DistortedTexture();

    if( fromJSON )

      {

      mNumStickerTypes = getNumStickerTypes();

      mNumCubitFaces = getNumCubitFaces();

      }

    else

      {

      FactoryCubit factory = FactoryCubit.getInstance();

      mStickerCoords   = factory.getStickerCoords();

      mStickerVariants = factory.getStickerVariants();

      mStickerScales   = factory.getStickerScales();

      adjustStickerCoords();

      mNumStickerTypes = (mStickerCoords==null ? 0 : mStickerCoords.length);

      }

    mStickerOverrides = getStickerOverrides();

    mNumOverrides = mStickerOverrides==null ? 0 : mStickerOverrides.length;

    mNumTextures= mNumFaceColors*mNumStickerTypes + mNumOverrides;

    mNumTexCols = NUM_STICKERS_IN_ROW;

    mNumTexRows = (mNumTextures+1)/NUM_STICKERS_IN_ROW;

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

    if( !fromDMESH || shouldResetTextureMaps() ) resetAllTextureMaps();

    else overrideCubitFaceColor();

    setTexture();

    }

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

  public InitData getInitData()

    {

    return mInitData;

    }

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

  public boolean isInIconMode()

    {

    return mIconMode==MODE_ICON;

    }

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

  public int getVariantStickerShape(int variant, int face)

    {

    return face>=mStickerVariants[variant].length ? -1 : mStickerVariants[variant][face];

    }

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

  public boolean shouldResetTextureMaps()

    {

    return false;

    }

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

  public int[][] getScrambleAlgorithms()

    {

    return ScrambleEdgeGenerator.getScramblingAlgorithms(mBasicAngles);

    }

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

  private boolean sticksOut(Static3D[] faceAxis, float[] dist, float x, float y, float z )

    {

    final float MAXERR = 0.05f;

    int numAxis = dist.length;

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

      {

      Static3D ax = faceAxis[i];

      float len = ax.get0()*x + ax.get1()*y + ax.get2()*z;

      if( len>mSize*dist[i]+MAXERR ) return true;

      }

    return false;

    }

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

  private boolean doesNotStickOut(int variant, float px, float py, float pz, float[] tmp, Static4D quat)

    {

    float[][] vertices = mShapes[variant].getVertices();

    Static3D[] axis = getFaceAxis();

    float[] dist3D = getDist3D(mNumLayers);

    for( float[] vertex : vertices)

      {

      float x = vertex[0];

      float y = vertex[1];

      float z = vertex[2];

      QuatHelper.rotateVectorByQuat(tmp, x, y, z, 1, quat);

      float mx = tmp[0] + px;

      float my = tmp[1] + py;

      float mz = tmp[2] + pz;

      if( sticksOut(axis, dist3D, mx,my,mz) ) return false;

      }

    return true;

    }

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

  private float computeAvg(float[] pos, int offset)

    {

    int len = pos.length/3;

    float ret=0.0f;

    for(int i=0; i<len; i++) ret += pos[3*i+offset];

    ret /= len;

    return ret;

    }

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

  protected void displayCubitQuats()

    {

    StringBuilder builder = new StringBuilder();

    float[] tmp = new float[4];

    float ERR = 0.01f;

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

      {

      builder.append(cubit);

      builder.append(" : ");

      int refCubit,variant = getCubitVariant(cubit,mNumLayers);

      for(refCubit=0; refCubit<mNumCubits; refCubit++)

        {

        if( getCubitVariant(refCubit,mNumLayers)==variant ) break;

        }

      float[] curpos = mOrigPos[cubit];

      float[] refpos = mOrigPos[refCubit];

      float refX = computeAvg(refpos,0);

      float refY = computeAvg(refpos,1);

      float refZ = computeAvg(refpos,2);

      float curX = computeAvg(curpos,0);

      float curY = computeAvg(curpos,1);

      float curZ = computeAvg(curpos,2);

      for(int quat=0; quat<mNumQuats; quat++)

        {

        QuatHelper.rotateVectorByQuat(tmp,refX,refY,refZ,0,mObjectQuats[quat]);

        float dx = tmp[0]-curX;

        float dy = tmp[1]-curY;

        float dz = tmp[2]-curZ;

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

          {

          if( doesNotStickOut(variant,curX,curY,curZ,tmp,mObjectQuats[quat]) )

            {

            builder.append(quat);

            builder.append(',');

            }

          else

            {

            android.util.Log.e("D", "cubit: "+cubit+" quat: "+quat+" : center correct, but shape sticks out");

            }

          }

        }

      builder.append('\n');

      }

    android.util.Log.e("D", "cubitQuats: \n"+builder );

    }

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

  public int getCubitRotationType(int cubit)

    {

    return TwistyObjectCubit.TYPE_NORMAL;

    }

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

  float[] getTrackingPoint(int cubitIndex, int cubitType)

    {

    if( cubitType!=TwistyObjectCubit.TYPE_NORMAL )

      {

      int variant = getCubitVariant(cubitIndex,mNumLayers);

      // object must have been created from JSON

      if( mVariantFaceIsOuter==null || mVariantFaceIsOuter[variant]==null )

        {

        mVariantFaceIsOuter = getVariantFaceIsOuter();

        }

      if( mShapes==null )

        {

        mShapes = new ObjectShape[mNumCubitVariants];

        }

      if( mShapes[variant]==null )

        {

        mShapes[variant] = getObjectShape(variant);

        }

      if( mOrigQuat==null )

        {

        mOrigQuat = new Static4D[mNumCubits];

        }

      if( mOrigQuat[cubitIndex]==null )

        {

        mOrigQuat[cubitIndex] = getCubitQuats(cubitIndex,mNumLayers);

        }

      int[][] indices = mShapes[variant].getVertIndices();

      int outer=-1, faces = indices.length;

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

        {

        if( mVariantFaceIsOuter[variant][i]==1 )

          {

          outer=i;

          break;

          }

        }

      if( outer>=0 )

        {

        int vertIndex = indices[outer][0];

        float[] vertices = mShapes[variant].getVertices()[vertIndex];

        float[] ret = new float[3];

        float[] curpos = mOrigPos[cubitIndex];

        Static4D quat = mOrigQuat[cubitIndex];

        QuatHelper.rotateVectorByQuat(mTmp, vertices[0], vertices[1], vertices[2], 1, quat);

        ret[0] = mTmp[0]+computeAvg(curpos,0);

        ret[1] = mTmp[1]+computeAvg(curpos,1);

        ret[2] = mTmp[2]+computeAvg(curpos,2);

        return ret;

        }

      else

        {

        android.util.Log.e("D", "Error in getTrackingPoint: no outer face??");

        }

      }

    return null;

    }

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

  public int computeCurrentPuzzleFace(int type, float[] vertex)

    {

    if( type!=TwistyObjectCubit.TYPE_NORMAL )

      {

      Static3D[] axis = getFaceAxis();

      float[] dist3D = getDist3D(mNumLayers);

      final float MAXERR = 0.98f;

      int numAxis = axis.length;

      float x = vertex[0];

      float y = vertex[1];

      float z = vertex[2];

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

        {

        Static3D ax = axis[i];

        float len = ax.get0()*x + ax.get1()*y + ax.get2()*z;

        if( len>mSize*dist3D[i]*MAXERR ) return i;

        }

      return -2;

      }

    return -1;

    }

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

  public float[] getCubitRowOffset(int cubitIndex)

    {

    return null;

    }

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

  void setRotationRowOffset(int puzzleFace, float[] offset)

    {

    mRowOffsets[puzzleFace][0] = offset[0];

    mRowOffsets[puzzleFace][1] = offset[1];

    mRowOffsets[puzzleFace][2] = offset[2];

    }

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

  int getNumAxis()

    {

    return mNumAxis;

    }

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

  public int[][] getSolvedQuats()

    {

    return mSolved.getSolvedQuats(mNumLayers,mNumCubitFaces,mCubitFaceColors);

    }

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

  public int getSolvedFunctionIndex()

    {

    return 0;

    }

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

  int computeRow(float[] pos, int axisIndex, int cubitType, int puzzleFace)

    {

    int ret=0;

    int len = pos.length / 3;

    Static3D axis = mAxis[axisIndex];

    float axisX = axis.get0();

    float axisY = axis.get1();

    float axisZ = axis.get2();