TwistyPuzzleLib

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

// Copyright 2019 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 static org.distorted.objectlib.helpers.OperatingSystemInterface.*;

import org.distorted.library.helpers.QuatHelper;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.effects.BaseEffect;

import org.distorted.objectlib.helpers.BlockController;

import org.distorted.objectlib.helpers.MovesFinished;

import org.distorted.objectlib.helpers.ObjectLibInterface;

import org.distorted.objectlib.helpers.OperatingSystemInterface;

import org.distorted.objectlib.touchcontrol.TouchControl;

import org.distorted.objectlib.touchcontrol.TouchControlShapeChanging;

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

public class ObjectControl

{

    public static final int MAX_MOVING_PARTS = 242; // Gigaminx

    public static final int MAX_QUATS = 60;         // Gigaminx: 60 quats group.

    public static final int NUM_SPEED_PROBES = 10;

    public static final int MODE_ROTATE  = 0;

    public static final int MODE_DRAG    = 1;

    public static final int MODE_REPLACE = 2;

    public static final int MODE_NOTHING = 3;

    public static final int ROT_AXIS_NOT_NORMAL = 0;

    public static final int ROT_AXIS_NORMAL_OPP = 1;

    public static final int ROT_AXIS_NORMAL_AGR = 2;

    // Moving the finger from the middle of the vertical screen to the right edge will rotate a

    // given face by SWIPING_SENSITIVITY/2 degrees.

    public final static int SWIPING_SENSITIVITY  = 240;

    // Moving the finger by 0.3 of an inch will start a Rotation.

    public final static float ROTATION_SENSITIVITY = 0.3f;

    private final Static4D CAMERA_POINT = new Static4D(0, 0, 0, 0);

    private final ObjectLibInterface mInterface;

    private final OperatingSystemInterface mOS;

    private final ObjectPreRender mPreRender;

    private TouchControl mTouchControl;

    private TwistyObjectNode mObjectNode;

    private boolean mDragging, mBeginningRotation, mContinuingRotation;

    private int mScreenWidth, mScreenHeight, mScalingSize;

    private float mMoveX, mMoveY;

    private int mLastMode;

    private float mRotAngle, mInitDistance;

    private float mStartRotX, mStartRotY;

    private float mRotationFactor;

    private int mCurrentAxis, mCurrentRow;

    private float mCurrentAngle, mAvgRotSpeed;

    private final float[] mLastA;

    private final long[] mLastT;

    private int mFirstIndex, mLastIndex;

    private final int mDensity;

    private float mX1, mY1, mX2, mY2, mX, mY;

    private final boolean mIsAutomatic;

    private boolean mIsLocked, mRemLocked;

    private final int[] mBuffer;

    private final float[] mAxis;

    private int mMeshState, mIconMode;

    private boolean mRotateOnCreation;

    private final Static4D mQuat,mTemp;

    private int mRotAxisType;

    private final float[] mNormalTouchPoint;

    private float mNormalRotAngle;

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

    private void addSpeedProbe(float angle)

      {

      long currTime = System.currentTimeMillis();

      boolean theSame = mLastIndex==mFirstIndex;

      mLastIndex++;

      if( mLastIndex>=NUM_SPEED_PROBES ) mLastIndex=0;

      mLastT[mLastIndex] = currTime;

      mLastA[mLastIndex] = angle;

      if( mLastIndex==mFirstIndex)

        {

        mFirstIndex++;

        if( mFirstIndex>=NUM_SPEED_PROBES ) mFirstIndex=0;

        }

      if( theSame )

        {

        mLastT[mFirstIndex] = currTime;

        mLastA[mFirstIndex] = angle;

        }

      }

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

    private void computeCurrentSpeedInInchesPerSecond()

      {

      long timeDiff = mLastT[mLastIndex]-mLastT[mFirstIndex];

      float sum = 0;

      for(int i=mFirstIndex; i<=mLastIndex; i++) sum += mLastA[i];

      mLastIndex = 0;

      mFirstIndex= 0;

      mAvgRotSpeed = timeDiff>0 ? sum/timeDiff : 0;

      if( mAvgRotSpeed<0 ) mAvgRotSpeed = -mAvgRotSpeed;

      }

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

    private float retFingerDragDistanceInInches(float xd, float yd)

      {

      float xDist = mScreenWidth*xd;

      float yDist = mScreenHeight*yd;

      float distInPixels = (float)Math.sqrt(xDist*xDist + yDist*yDist);

      return distInPixels/mDensity;

      }

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

    private void replaceMode(boolean down)

      {

      mBeginningRotation= false;

      if( down )

        {

        int cubit = mTouchControl.getTouchedCubit();

        int face  = mTouchControl.getTouchedCubitFace();

        mInterface.onReplaceModeDown(cubit,face);

        }

      }

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

    private void setUpDragOrRotate(boolean down, float x, float y)

      {

      if( mLastMode==MODE_DRAG )

        {

        mDragging           = true;

        mBeginningRotation  = false;

        mContinuingRotation = false;

        }

      else

        {

        CAMERA_POINT.set2( mObjectNode.getCameraDist() );

        Static4D touchPoint = new Static4D(x, y, 0, 0);

        Static4D rotatedTouchPoint= QuatHelper.rotateVectorByInvertedQuat(touchPoint, mQuat);

        Static4D rotatedCamera= QuatHelper.rotateVectorByInvertedQuat(CAMERA_POINT, mQuat);

        if( mTouchControl!=null && mTouchControl.objectTouched(rotatedTouchPoint,rotatedCamera) )

          {

          mDragging           = false;

          mContinuingRotation = false;

               if( mLastMode==MODE_ROTATE  ) mBeginningRotation = !mPreRender.isRotationBlocked();

          else if( mLastMode==MODE_REPLACE ) replaceMode(down);

          }

        else

          {

          mDragging           = (!mIsLocked || mIsAutomatic);

          mBeginningRotation  = false;

          mContinuingRotation = false;

          if( !mDragging ) mInterface.failedToDrag();

          }

        }

      }

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

    private void drag(float x, float y)

      {

      if( mOS.isFirstPressed() && mOS.isSecondPressed() )

        {

        float x2 = (mX2 - mScreenWidth*0.5f)/ mScalingSize;

        float y2 = (mScreenHeight*0.5f - mY2)/ mScalingSize;

        float angleNow = getAngle(x,y,x2,y2);

        float angleDiff = angleNow-mRotAngle;

        float sinA =-(float)Math.sin(angleDiff);

        float cosA = (float)Math.cos(angleDiff);

        Static4D dragQuat = QuatHelper.quatMultiply(new Static4D(0,0,sinA,cosA), mQuat);

        mTemp.set(dragQuat);

        mRotAngle = angleNow;

        float distNow  = (float)Math.sqrt( (x-x2)*(x-x2) + (y-y2)*(y-y2) );

        float distQuot = mInitDistance<0 ? 1.0f : distNow/ mInitDistance;

        mInitDistance = distNow;

        TwistyObject object = mPreRender.getObject();

        if( object!=null )

          {

          object.setObjectRatio(distQuot, mScalingSize );

          float ratio = object.getObjectRatio();

          if( mLastMode==MODE_REPLACE ) mTouchControl.setObjectRatio(ratio);

          }

        }

      else

        {

        Static4D dragQuat = QuatHelper.quatMultiply(QuatHelper.quatFromDrag(mX-x,y-mY), mQuat);

        mTemp.set(dragQuat);

        }

      mPreRender.setQuatOnNextRender();

      mX = x;

      mY = y;

      }

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

    private void finishRotation()

      {

      TwistyObject object = mPreRender.getObject();

      int[][] angles = object.getBasicAngles();

      if( mCurrentAxis<angles.length && mCurrentRow<angles[mCurrentAxis].length )

        {

        computeCurrentSpeedInInchesPerSecond();

        int basic = angles[mCurrentAxis][mCurrentRow];

        int angle = object.computeNearestAngle(basic,mCurrentAngle, mAvgRotSpeed);

        mPreRender.finishRotation(angle);

        mPreRender.rememberMove(mCurrentAxis,mCurrentRow,angle);

        if( angle!=0 )

          {

          int realAngle = (angle*basic)/360;

          mInterface.onFinishRotation(mCurrentAxis,mCurrentRow,realAngle);

          }

        mContinuingRotation = false;

        mBeginningRotation  = false;

        mDragging           = true;

        }

      }

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

    private void continueRotation(float x, float y)

      {

      if( mRotAxisType == ROT_AXIS_NOT_NORMAL )

        {

        float dx = x-mStartRotX;

        float dy = y-mStartRotY;

        float alpha = dx*mAxis[0] + dy*mAxis[1];

        float x2 = dx - alpha*mAxis[0];

        float y2 = dy - alpha*mAxis[1];

        float len = (float)Math.sqrt(x2*x2 + y2*y2);

        // we have the length of 1D vector 'angle', now the direction:

        float tmp = mAxis[1]==0 ? -mAxis[0]*y2 : mAxis[1]*x2;

        float angle = (tmp>0 ? 1:-1)*len*mRotationFactor;

        mCurrentAngle = SWIPING_SENSITIVITY*angle;

        mPreRender.getObject().continueRotation(mCurrentAngle);

        addSpeedProbe(mCurrentAngle);

        }

      else

        {

        float rotAngle = computeNormalRotAngle(mNormalTouchPoint[0]-x,mNormalTouchPoint[1]-y);

        mCurrentAngle = mNormalRotAngle - rotAngle;

        if( mRotAxisType==ROT_AXIS_NORMAL_AGR ) mCurrentAngle = -mCurrentAngle;

        mPreRender.getObject().continueRotation(mCurrentAngle);

        addSpeedProbe(mCurrentAngle);

        }

      }

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

    private void correctRotationAxis()

      {

      if( mAxis[0]==0 && mAxis[1]==0 )

        {

        // 0. get face center in object space

        // 1. multiply it by mQuat

        // 2. multiply if by mObjectRatio. Let the result be (x,y,z)

        // 3. let D be CAMERA_POINT.Z

        // 4. then compute the point on the screen (X,Y) the face center maps to:

        //    (X,Y) = (Ax,Ay) where A = D/(D-z)

        float[] faceCenter = mTouchControl.getTouchedPuzzleCenter();

        float D = CAMERA_POINT.get2();

        float[] rotated = new float[4];

        QuatHelper.rotateVectorByQuat(rotated, faceCenter[0],faceCenter[1],faceCenter[2],faceCenter[3],mQuat);

        TwistyObject object = getObject();

        float ratio = object.getObjectRatio();

        float x = rotated[0] * ratio;

        float y = rotated[1] * ratio;

        float z = rotated[2] * ratio;

        float A = D / (D-z);

        mNormalTouchPoint[0] = A*x;

        mNormalTouchPoint[1] = A*y;

        boolean agree = mTouchControl.axisAndFaceAgree(mCurrentAxis);

        mRotAxisType = (agree ? ROT_AXIS_NORMAL_AGR : ROT_AXIS_NORMAL_OPP);

        }

      else

        {

        mRotAxisType = ROT_AXIS_NOT_NORMAL;

        }

      }

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

// in degrees

    private float computeNormalRotAngle(float vx, float vy)

      {

      return (float)((180*Math.atan2(vy,vx))/Math.PI);

      }

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

    private void beginRotation(float x, float y)

      {

      mStartRotX = x;

      mStartRotY = y;

      TwistyObject object = mPreRender.getObject();

      int[] numLayers = object.getNumLayers();

      Static4D touchPoint = new Static4D(x, y, 0, 0);

      Static4D rotatedTouchPoint= QuatHelper.rotateVectorByInvertedQuat(touchPoint, mQuat);

      mTouchControl.newRotation(mBuffer,rotatedTouchPoint,mQuat);

      mCurrentAxis = mBuffer[0];

      mCurrentRow  = mBuffer[1];

      mTouchControl.getCastedRotAxis(mAxis,mQuat,mCurrentAxis);

      correctRotationAxis();

      mRotationFactor = mTouchControl.returnRotationFactor(numLayers,mCurrentRow);

      if( mRotAxisType != ROT_AXIS_NOT_NORMAL ) mNormalRotAngle = computeNormalRotAngle(mNormalTouchPoint[0]-x,mNormalTouchPoint[1]-y);

      if( object.beginNewRotation( mCurrentAxis, mCurrentRow ) )

        {

        mInterface.onBeginRotation();

        addSpeedProbe(0);

        mBeginningRotation = false;

        mContinuingRotation= true;

        }

      }

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

    private float getAngle(float x1, float y1, float x2, float y2)

      {

      return (float) Math.atan2(y1-y2, x1-x2);

      }

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

    private void prepareDown()

      {

      mOS.pressFirst();

      mOS.unpressSecond();

      mX1 = mOS.getFirstX() - mMoveX;

      mY1 = mOS.getFirstY() + mMoveY;

      }

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

    private void prepareMove()

      {

      int index1 = mOS.getFirstPointerIndex();

      if( index1>=0 )

        {

        mX1 = mOS.getX(index1) - mMoveX;

        mY1 = mOS.getY(index1) + mMoveY;

        }

      int index2 = mOS.getSecondPointerIndex();

      if( index2>=0 )

        {

        mX2 = mOS.getX(index2) - mMoveX;

        mY2 = mOS.getY(index2) + mMoveY;

        }

      }

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

    private void prepareUp()

      {

      mOS.unpressFirst();

      mOS.unpressSecond();

      }

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

    private void prepareDown2()

      {

      if( !mOS.isFirstPressed() )

        {

        mOS.pressFirst();

        mX1 = mOS.getFirstX() - mMoveX;

        mY1 = mOS.getFirstY() + mMoveY;

        }

      else if( !mOS.isSecondPressed() )

        {

        mOS.pressSecond();

        mX2 = mOS.getSecondX() - mMoveX;

        mY2 = mOS.getSecondY() + mMoveY;

        }

      }

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

    private void prepareUp2()

      {

      mOS.upOneOfThem();

      }

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

    private void actionMove(float x1, float y1, float x2, float y2)

      {

      float pX,pY;

      if( mOS.isFirstPressed() ) { pX = x1; pY=y1; }

      else                       { pX = x2; pY=y2; }

      float x = (pX - mScreenWidth*0.5f)/ mScalingSize;

      float y = (mScreenHeight*0.5f -pY)/ mScalingSize;

      if( mBeginningRotation )

        {

        if( retFingerDragDistanceInInches(mX-x,mY-y) > ROTATION_SENSITIVITY )

          {

          beginRotation(x,y);

          }

        }

      else if( mContinuingRotation )

        {

        continueRotation(x,y);

        }

      else if( mDragging )

        {

        drag(x,y);

        }

      else

        {

        setUpDragOrRotate(false,x,y);

        }

      }

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

    private void actionDown(float x, float y)

      {

      mX = (x -  mScreenWidth*0.5f)/ mScalingSize;

      mY = (mScreenHeight*0.5f - y)/ mScalingSize;

      setUpDragOrRotate(true,mX,mY);

      }

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

    private void actionUp()

      {

      if( mContinuingRotation )

        {

        finishRotation();

        }

      if( mLastMode==MODE_REPLACE ) mInterface.onReplaceModeUp();

      }

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

    private void actionDown2(float x1, float y1, float x2, float y2)

      {

      mRotAngle = getAngle(x1,-y1, x2,-y2);

      mInitDistance = -1;

      mX = (x1 - mScreenWidth*0.5f )/ mScalingSize;

      mY = (mScreenHeight*0.5f - y1)/ mScalingSize;

      if( mBeginningRotation )

        {

        mContinuingRotation = false;

        mBeginningRotation  = false;

        mDragging           = true;

        }

      else if( mContinuingRotation )

        {

        finishRotation();

        }

      }

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

    private void actionUp2(boolean p1isUp, float x1, float y1, boolean p2isUp, float x2, float y2)

      {

      if( p1isUp )

        {

        mX = (x2 -  mScreenWidth*0.5f)/ mScalingSize;

        mY = (mScreenHeight*0.5f - y2)/ mScalingSize;

        }

      if( p2isUp )

        {

        mX = (x1 -  mScreenWidth*0.5f)/ mScalingSize;

        mY = (mScreenHeight*0.5f - y1)/ mScalingSize;

        }

      }

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

    int getScalingSize()

      {

      return mScalingSize;

      }

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

    void setTouchControl(TwistyObject object)

      {

      if( mLastMode!=MODE_REPLACE ) mTouchControl = object.getTouchControl();

      else                          mTouchControl = new TouchControlShapeChanging(object);

      }

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

// INTERNAL API (for AutomaticControl)

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

    public ObjectPreRender getPreRender()

      {

      return mPreRender;

      }

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

    public ObjectLibInterface getInterface()

      {

      return mInterface;

      }

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

// PUBLIC API

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

    public ObjectControl(OperatingSystemInterface os)

      {

      mIsAutomatic = false;

      mBuffer = new int[2];

      mAxis   = new float[2];

      mQuat= new Static4D(-0.25189602f,0.3546389f,0.009657208f,0.90038127f);

      mTemp= new Static4D(0,0,0,1);

      mAvgRotSpeed = 0.0f;

      mLastMode    = -1;

      mRotateOnCreation = false;

      mNormalTouchPoint = new float[2];

      mLastA = new float[NUM_SPEED_PROBES];

      mLastT = new long[NUM_SPEED_PROBES];

      mFirstIndex= 0;

      mLastIndex = 0;

      mMeshState =-1;

      mIconMode  =-1;

      mInterface = os.getInterface();

      mOS = os;

      mDensity = mOS.getScreenDensity();

      mPreRender = new ObjectPreRender(this,mInterface);

      }

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

    public void setRotateOnCreation(boolean rotate)

      {

      mRotateOnCreation = rotate;

      }

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

    public boolean getRotateOnCreation()

      {

      return mRotateOnCreation;

      }

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

    public TwistyObjectNode getNode()

      {

      return mObjectNode;

      }

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

    public void createNode(int width, int height)

      {

      if( mObjectNode==null ) mObjectNode = new TwistyObjectNode(width,height);

      }

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

    public void setScreenSizeAndScaling(int width, int height, int scaling)

      {

      mScreenWidth = width;

      mScreenHeight= height;

      mScalingSize = scaling;

      if( mObjectNode!=null ) mObjectNode.setSize(width,height);

      TwistyObject object = mPreRender.getObject();

      if( object!=null )

        {

        object.setTexture();

        object.setNodeSize(mScalingSize);

        }

      }

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

    public void setObjectMove(int xmove, int ymove)

      {

      mMoveX = xmove;

      mMoveY = ymove;

      mPreRender.setMove(xmove,ymove);

      }

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

    public void setObjectScale(float scale)

      {

      mPreRender.setScale(scale);

      }

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

    public void onPause()

      {

      BlockController.onPause();

      }

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

    public void onResume()

      {

      mOS.unpressFirst();

      mOS.unpressSecond();

      unlock();

      BlockController.onResume();

      }

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

    public void rotateNow(Static4D quat)

      {

      mTemp.set(quat);

      mQuat.set(mTemp);

      }

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

    public void scaleNow(float scale)

      {

      mPreRender.getObject().setObjectRatioNow(scale,mScalingSize );

      }

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

    public void setQuat()

      {

      mQuat.set(mTemp);

      }

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

    public Static4D getQuat()

      {

      return mQuat;

      }

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

    public void preRender()

      {

      mPreRender.preRender();

      }

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

    public void blockTouch(int place)

      {

      setLock(true);

      mPreRender.blockRotation(place);

      }

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

    public void unblockRotation()

      {

      unsetLock();

      mPreRender.unblockRotation();

      }

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

    public void unblockEverything()

      {

      mPreRender.unblockEverything();

      }

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

    public boolean isScramblingAndSolvingNotBlocked()

      {

      return mPreRender.isScramblingAndSolvingNotBlocked();

      }

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

    public void initializeObject(int[][] moves)

      {

      mPreRender.initializeObject(moves);

      }

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

    public void changeObject(int ordinal, int meshState, int iconMode, InitAssets asset)

      {

      mPreRender.changeObject(ordinal, meshState, iconMode, asset);

      }

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

    public void changeIfDifferent(int ordinal, String newName, int meshState, int iconMode, InitAssets asset)

      {

      TwistyObject object = mPreRender.getObject();

      String oldName = object==null ? "" : object.getShortName();

      if( !oldName.equals(newName) || mMeshState!=meshState || mIconMode!=iconMode )

        {

        mMeshState = meshState;

        mIconMode  = iconMode;

        mPreRender.changeObject(ordinal, meshState, iconMode, asset);

        }

      }

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

// if one or more fingers currently touch the screen, and we just pressed the 'scramble' button, do

// not scramble - otherwise a kind of a cheat is possible where user touches the screen, starts

// scrambling, then lifts the finger and the act of lifting screws the scrambling - no further

// scrambles take any effect!

    public boolean scrambleObject(int num)

      {

      if( !mBeginningRotation && !mContinuingRotation )

        {

        return mPreRender.scrambleObject(num);

        }

      return false;

      }

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

// ditto

    public boolean fastScrambleObject(int duration, int num)

      {

      if( !mBeginningRotation && !mContinuingRotation )

        {

        return mPreRender.fastScrambleObject(duration,num);

        }

      return false;

      }

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

    public void presentObject(int num, int duration)

      {

      mPreRender.presentObject(num,duration);

      }

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

    public void solveObject()

      {

      mPreRender.solveObject();

      }

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

    public void solveOnly()

      {

      mPreRender.solveOnly();

      }

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

    public void resetTextureMapsEffect(int duration)

      {

      mPreRender.resetTextureMapsEffect(duration);

      }

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

    public void addRotation(MovesFinished listener, int axis, int rowBitmap, int angle, int duration)

      {

      mPreRender.addRotation(listener,axis,rowBitmap,angle,duration);

      }

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

    public void resetAllTextureMaps()

      {

      mPreRender.resetAllTextureMaps();

      }

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

    public TwistyObject getObject()

      {

      return mPreRender.getObject();

      }

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

    public OperatingSystemInterface getOS()

      {

      return mOS;

      }

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

    public void savePreferences()

      {

      mPreRender.savePreferences(mOS);

      for( int i=0; i< BaseEffect.Type.LENGTH; i++ )

        {

        BaseEffect.Type.getType(i).savePreferences(mOS);

        }

      }

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

    public void restorePreferences()

      {

      mPreRender.restorePreferences(mOS);

      for (int i=0; i<BaseEffect.Type.LENGTH; i++)

        {

        BaseEffect.Type.getType(i).restorePreferences(mOS);

        }

      }

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

    public boolean retLocked()

      {

      return mIsLocked;

      }

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

    public void toggleLock()

      {

      mIsLocked = !mIsLocked;

      }

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

    public void unlock()

      {

      mIsLocked = false;

      }

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

    public void setLock(boolean value)

      {

      mRemLocked = mIsLocked;

      mIsLocked = value;

      }

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

    public void unsetLock()

      {

      mIsLocked = mRemLocked;

      }

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

    public void setTextureMap(int cubit, int face, int newColor)