TwistyPuzzleLib

import org.distorted.objectlib.main.ObjectPreRender;

          ObjectPreRender pre = act.getPreRender();

          ObjectPreRender pre = act.getPreRender();

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

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

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.main.Movement;

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

public interface ObjectSurfaceView

  {

  TwistyActivity getActivity();

  void setMovement(Movement move);

  Static4D getQuat();

  void setQuat();

  DistortedScreen getScreen();

  }

import org.distorted.objectlib.main.ObjectPreRender;

  public abstract ObjectPreRender getPreRender();

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

// 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 org.distorted.objectlib.helpers.ObjectStateActioner;

import org.distorted.objectlib.helpers.ObjectSurfaceView;

import org.distorted.objectlib.effects.BaseEffect;

import org.distorted.objectlib.effects.EffectController;

import org.distorted.objectlib.effects.scramble.ScrambleEffect;

import org.distorted.objectlib.helpers.BlockController;

import org.distorted.objectlib.helpers.MovesFinished;

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

public class ObjectPreRender implements EffectController

  {

  private final ObjectSurfaceView mView;

  private ObjectType mNextObject;

  private TwistyObject mOldObject, mNewObject;

  private SharedPreferences mPreferences;

  private MovesFinished mAddActionListener;

  private final BlockController mBlockController;

  private final ObjectStateActioner mActioner;

  private String mDebug;

  private boolean mFinishRotation, mRemoveRotation, mRemovePatternRotation, mAddRotation,

                  mSetQuat, mChangeObject, mSetupObject, mSolveObject, mScrambleObject,

                  mInitializeObject, mSetTextureMap, mResetAllTextureMaps, mSolve;

  private boolean mUIBlocked, mTouchBlocked, mIsSolved;

  private long mRotationFinishedID;

  private final long[] mEffectID;

  private int mScreenWidth;

  private int[][] mNextMoves;

  private int mScrambleObjectNum;

  private int mAddRotationAxis, mAddRotationRowBitmap, mAddRotationAngle;

  private long mAddRotationDuration;

  private long mAddRotationID, mRemoveRotationID;

  private int mCubit, mFace, mNewColor;

  private int mNearestAngle;

  private long mDebugStartTime;

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

  public ObjectPreRender(ObjectSurfaceView view, ObjectStateActioner actioner)

    {

    mView = view;

    mActioner = actioner;

    mFinishRotation       = false;

    mRemoveRotation       = false;

    mRemovePatternRotation= false;

    mAddRotation          = false;

    mSetQuat              = false;

    mChangeObject         = false;

    mSetupObject          = false;

    mSolveObject          = false;

    mSolve                = false;

    mScrambleObject       = false;

    mOldObject = null;

    mNewObject = null;

    mDebug = "";

    mScreenWidth = 0;

    mScrambleObjectNum = 0;

    mEffectID = new long[BaseEffect.Type.LENGTH];

    mBlockController = new BlockController(mView.getActivity());

    unblockEverything();

    }

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

  private void createObjectNow(ObjectType object, int[][] moves)

    {

    boolean firstTime = (mNewObject==null);

    if( mOldObject!=null ) mOldObject.releaseResources();

    mOldObject = mNewObject;

    Resources res = mView.getActivity().getResources();

    mNewObject = object.create(mView.getQuat(), moves, res, mScreenWidth);

    if( mNewObject!=null )

      {

      mView.setMovement(mNewObject.getMovement());

      if( firstTime ) mNewObject.restorePreferences(mPreferences);

      mIsSolved = mNewObject.isSolved();

      }

    }

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

// do all 'adjustable' effects (SizeChange, Solve, Scramble)

  private void doEffectNow(BaseEffect.Type type)

    {

    try

      {

      int index = type.ordinal();

      mEffectID[index] = type.startEffect(mView.getScreen(),this);

      }

    catch( Exception ex )

      {

      android.util.Log.e("renderer", "exception starting effect: "+ex.getMessage());

      unblockEverything();

      }

    }

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

  private void removeRotationNow()

    {

    mRemoveRotation=false;

    mNewObject.removeRotationNow();

    boolean solved = mNewObject.isSolved();

    if( solved && !mIsSolved )

      {

      mActioner.onSolved();

      unblockEverything();

      doEffectNow( BaseEffect.Type.WIN );

      }

    else

      {

      unblockEverything();

      }

    mIsSolved = solved;

    }

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

  private void removeRotation()

    {

    mRemoveRotation = true;

    }

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

  private void removePatternRotation()

    {

    mRemovePatternRotation = true;

    }

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

  private void removePatternRotationNow()

    {

    mRemovePatternRotation=false;

    mNewObject.removeRotationNow();

    mAddActionListener.onActionFinished(mRemoveRotationID);

    }

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

  private void addRotationNow()

    {

    mAddRotation = false;

    mAddRotationID = mNewObject.addNewRotation( mAddRotationAxis, mAddRotationRowBitmap,

                                                mAddRotationAngle, mAddRotationDuration, this);

    if( mAddRotationID==0 ) // failed to add effect - should never happen

      {

      unblockEverything();

      }

    }

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

  private void finishRotationNow()

    {

    mFinishRotation = false;

    blockEverything(BlockController.RUBIK_PLACE_0);

    mRotationFinishedID = mNewObject.finishRotationNow(this, mNearestAngle);

    if( mRotationFinishedID==0 ) // failed to add effect - should never happen

      {

      unblockEverything();

      }

    }

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

  private void changeObjectNow()

    {

    mChangeObject = false;

    if ( mNewObject==null || mNewObject.getObjectType()!=mNextObject )

      {

      blockEverything(BlockController.RUBIK_PLACE_1);

      createObjectNow(mNextObject, null);

      doEffectNow( BaseEffect.Type.SIZECHANGE );

      }

    }

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

  private void setupObjectNow()

    {

    mSetupObject = false;

    if ( mNewObject==null || mNewObject.getObjectType()!=mNextObject)

      {

      blockEverything(BlockController.RUBIK_PLACE_2);

      createObjectNow(mNextObject, mNextMoves);

      doEffectNow( BaseEffect.Type.SIZECHANGE );

      }

    else

      {

      mNewObject.initializeObject(mNextMoves);

      }

    }

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

  private void scrambleObjectNow()

    {

    mScrambleObject = false;

    mIsSolved       = false;

    blockEverything(BlockController.RUBIK_PLACE_3);

    doEffectNow( BaseEffect.Type.SCRAMBLE );

    }

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

  private void solveObjectNow()

    {

    mSolveObject = false;

    blockEverything(BlockController.RUBIK_PLACE_4);

    doEffectNow( BaseEffect.Type.SOLVE );

    }

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

  private void solveNow()

    {

    mSolve = false;

    mNewObject.solve();

    }

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

  private void initializeObjectNow()

    {

    mInitializeObject = false;

    mNewObject.initializeObject(mNextMoves);

    }

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

  private void setTextureMapNow()

    {

    mSetTextureMap = false;

    if( mNewObject!=null ) mNewObject.setTextureMap(mCubit,mFace,mNewColor);

    }

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

  private void resetAllTextureMapsNow()

    {

    mResetAllTextureMaps = false;

    if( mNewObject!=null ) mNewObject.resetAllTextureMaps();

    }

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

  private void setQuatNow()

    {

    mSetQuat = false;

    mView.setQuat();

    }

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

// PUBLIC API

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

  public void rememberMove(int axis, int row, int angle)

    {

    mDebug += (" (m "+axis+" "+(1<<row)+" "+angle+" "+(System.currentTimeMillis()-mDebugStartTime)+")");

    }

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

  public void setScreenSize(int width)

    {

    if( mNewObject!=null )

      {

      mNewObject.createTexture();

      mNewObject.recomputeScaleFactor(width);

      }

    mScreenWidth = width;

    }

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

  public void savePreferences(SharedPreferences.Editor editor)

    {

    if( mNewObject!=null )

      {

      mNewObject.savePreferences(editor);

      }

    }

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

  public void restorePreferences(SharedPreferences preferences)

    {

    mPreferences = preferences;

    }

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

  public void finishRotation(int nearestAngle)

    {

    mNearestAngle   = nearestAngle;

    mFinishRotation = true;

    }

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

  public void changeObject(ObjectType object)

    {

    mChangeObject = true;

    mNextObject = object;

    }

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

  public void setupObject(ObjectType object, int[][] moves)

    {

    mSetupObject= true;

    mNextObject = object;

    mNextMoves  = moves;

    }

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

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

    {

    mSetTextureMap = true;

    mCubit    = cubit;

    mFace     = face;

    mNewColor = newColor;

    }

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

  public boolean isTouchBlocked()

    {

    return mTouchBlocked;

    }

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

  public boolean isUINotBlocked()

    {

    return !mUIBlocked;

    }

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

  public void blockEverything(int place)

    {

    mUIBlocked   = true;

    mTouchBlocked= true;

    mBlockController.touchBlocked(place);

    mBlockController.uiBlocked(place);

    }

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

  public void blockTouch(int place)

    {

    mTouchBlocked= true;

    mBlockController.touchBlocked(place);

    }

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

  public void unblockEverything()

    {

    mUIBlocked   = false;

    mTouchBlocked= false;

    mBlockController.touchUnblocked();

    mBlockController.uiUnblocked();

    }

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

  public void unblockTouch()

    {

    mTouchBlocked= false;

    mBlockController.touchUnblocked();

    }

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

  public void unblockUI()

    {

    mUIBlocked= false;

    mBlockController.uiUnblocked();

    }

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

  public void setQuatOnNextRender()

    {

    mSetQuat = true;

    }

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

  public void preRender()

    {

    if( mSolve                 ) solveNow();

    if( mSetQuat               ) setQuatNow();

    if( mFinishRotation        ) finishRotationNow();

    if( mRemoveRotation        ) removeRotationNow();

    if( mRemovePatternRotation ) removePatternRotationNow();

    if( mChangeObject          ) changeObjectNow();

    if( mSetupObject           ) setupObjectNow();

    if( mSolveObject           ) solveObjectNow();

    if( mScrambleObject        ) scrambleObjectNow();

    if( mAddRotation           ) addRotationNow();

    if( mInitializeObject      ) initializeObjectNow();

    if( mResetAllTextureMaps   ) resetAllTextureMapsNow();

    if( mSetTextureMap         ) setTextureMapNow();

    }

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

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

    {

    mAddRotation = true;

    mAddActionListener    = listener;

    mAddRotationAxis      = axis;

    mAddRotationRowBitmap = rowBitmap;

    mAddRotationAngle     = angle;

    mAddRotationDuration  = duration;

    if( listener instanceof ScrambleEffect )

      {

      mDebug += (" (a "+axis+" "+rowBitmap+" "+angle+" "+(System.currentTimeMillis()-mDebugStartTime)+")");

      }

    }

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

  public void initializeObject(int[][] moves)

    {

    mInitializeObject = true;

    mNextMoves = moves;

    }

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

  public void scrambleObject(int num)

    {

    if( !mUIBlocked )

      {

      mScrambleObject = true;

      mScrambleObjectNum = num;

      mDebug = "";

      mDebugStartTime = System.currentTimeMillis();

      }

    }

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

// this starts the Solve Effect

  public void solveObject()

    {

    if( !mUIBlocked )

      {

      mSolveObject = true;

      }

    }

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

// this only sets the cubits state to solved

  public void solve()

    {

    mSolve = true;

    }

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

  public void resetAllTextureMaps()

    {

    mResetAllTextureMaps = true;

    }

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

  public TwistyObject getObject()

    {

    return mNewObject;

    }

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

  public TwistyObject getOldObject()

    {

    return mOldObject;

    }

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

  public int getNumScrambles()

    {

    return mScrambleObjectNum;

    }

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

  public void effectFinished(final long effectID)

    {

    if( effectID == mRotationFinishedID )

      {

      mRotationFinishedID = 0;

      removeRotation();

      }

    else if( effectID == mAddRotationID )

      {

      mAddRotationID = 0;

      mRemoveRotationID = effectID;

      removePatternRotation();

      }

    else

      {

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

        {

        if( effectID == mEffectID[i] )

          {

          if( i!=BaseEffect.Type.WIN.ordinal() ) unblockEverything();

          if( i==BaseEffect.Type.SCRAMBLE.ordinal() ) mActioner.onScrambleEffectFinished(mView.getActivity());

          if( i==BaseEffect.Type.WIN.ordinal()      ) mActioner.onWinEffectFinished(mView.getActivity(),mDebug,mScrambleObjectNum);

          break;

          }

        }

      }

    }

  }

// INTERNAL API

  public void randomizeNewScramble(int[][] scramble, Random rnd, int curr, int total)

    mScrambler.randomizeNewScramble(scramble,rnd,curr,total);

  public int getNodeSize()

    return mNodeSize;

    }

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

  public void initializeObject(int[][] moves)

    {

    solve();

    setupPosition(moves);

    }

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

  public synchronized void removeRotationNow()

    {

    float angle = getAngle();

    double nearestAngleInRadians = angle*Math.PI/180;

    float sinA =-(float)Math.sin(nearestAngleInRadians*0.5);

    float cosA = (float)Math.cos(nearestAngleInRadians*0.5);

    float axisX = mAxis[mRotAxis].get0();

    float axisY = mAxis[mRotAxis].get1();

    float axisZ = mAxis[mRotAxis].get2();

    Static4D quat = new Static4D( axisX*sinA, axisY*sinA, axisZ*sinA, cosA);

    mRotationAngle.removeAll();

    mRotationAngleStatic.set0(0);

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

      if( belongsToRotation(i,mRotAxis,mRotRowBitmap) )

        int index = CUBITS[i].removeRotationNow(quat);

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

  public long finishRotationNow(EffectListener listener, int nearestAngleInDegrees)

    if( wasRotateApplied() )

      {

      float angle = getAngle();

      mRotationAngleStatic.set0(angle);

      mRotationAngleFinal.set0(nearestAngleInDegrees);

      mRotationAngleMiddle.set0( nearestAngleInDegrees + (nearestAngleInDegrees-angle)*0.2f );

      mRotationAngle.setDuration(POST_ROTATION_MILLISEC);

      mRotationAngle.resetToBeginning();

      mRotationAngle.removeAll();

      mRotationAngle.add(mRotationAngleStatic);

      mRotationAngle.add(mRotationAngleMiddle);

      mRotationAngle.add(mRotationAngleFinal);

      mRotateEffect.notifyWhenFinished(listener);

      return mRotateEffect.getID();

      }

    return 0;

  public synchronized long addNewRotation( int axis, int rowBitmap, int angle, long durationMillis, EffectListener listener )

    if( wasRotateApplied() )

      {

      mRotAxis     = axis;

      mRotRowBitmap= computeBitmapFromRow( rowBitmap,axis );

      mRotationAngleStatic.set0(0.0f);

      mRotationAxis.set( mAxis[axis] );

      mRotationAngle.setDuration(durationMillis);

      mRotationAngle.resetToBeginning();

      mRotationAngle.add(new Static1D(0));

      mRotationAngle.add(new Static1D(angle));

      mRotateEffect.setMeshAssociation( mRotRowBitmap<<(axis*ObjectType.MAX_OBJECT_SIZE) , -1);

      mRotateEffect.notifyWhenFinished(listener);

      return mRotateEffect.getID();

      }

    return 0;

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

    final float ratioW = 1.0f/mNumTexCols;

    final float ratioH = 1.0f/mNumTexRows;

    final Static4D[] maps = new Static4D[mNumCubitFaces];

    int row = (mNumTexRows-1) - newColor/mNumTexCols;

    int col = newColor%mNumTexCols;

    maps[face] = new Static4D( col*ratioW, row*ratioH, ratioW, ratioH);

    mMesh.setTextureMap(maps,mNumCubitFaces*cubit);

  public void resetAllTextureMaps()

    final float ratioW = 1.0f/mNumTexCols;

    final float ratioH = 1.0f/mNumTexRows;

    int color, row, col;

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

      final Static4D[] maps = new Static4D[mNumCubitFaces];

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

        {

        color = getFaceColor(cubit,cubitface,mNumLayers);

        row = (mNumTexRows-1) - color/mNumTexCols;

        col = color%mNumTexCols;

        maps[cubitface] = new Static4D( col*ratioW, row*ratioH, ratioW, ratioH);

        }

      mMesh.setTextureMap(maps,mNumCubitFaces*cubit);

      }

  public void releaseResources()

    mTexture.markForDeletion();

    mMesh.markForDeletion();

    mEffects.markForDeletion();

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

      {

      CUBITS[j].releaseResources();

      }

  public void savePreferences(SharedPreferences.Editor editor)

    for(int i=0; i<NUM_CUBITS; i++) CUBITS[i].savePreferences(editor);

  public void recomputeScaleFactor(int scrWidth)

    mNodeScale.set(scrWidth,NODE_RATIO*scrWidth,scrWidth);

  public Static4D getRotationQuat()

      return mQuat;

// the getFaceColors + final black in a grid (so that we do not exceed the maximum texture size)

  public void createTexture()

    Bitmap bitmap;

    Paint paint = new Paint();

    bitmap = Bitmap.createBitmap( mNumTexCols*TEXTURE_HEIGHT, mNumTexRows*TEXTURE_HEIGHT, Bitmap.Config.ARGB_8888);

    Canvas canvas = new Canvas(bitmap);

    paint.setAntiAlias(true);

    paint.setTextAlign(Paint.Align.CENTER);

    paint.setStyle(Paint.Style.FILL);

    paint.setColor(COLOR_BLACK);

    canvas.drawRect(0, 0, mNumTexCols*TEXTURE_HEIGHT, mNumTexRows*TEXTURE_HEIGHT, paint);

    int face = 0;

    FactorySticker factory = FactorySticker.getInstance();

    for(int row=0; row<mNumTexRows; row++)

      for(int col=0; col<mNumTexCols; col++)

        if( face>=NUM_TEXTURES ) break;

        ObjectSticker sticker = retSticker(face);

        factory.drawRoundedPolygon(canvas, paint, col*TEXTURE_HEIGHT, row*TEXTURE_HEIGHT, getColor(face%NUM_FACE_COLORS), sticker);

        face++;

    if( !mTexture.setTexture(bitmap) )

      {

      int max = DistortedLibrary.getMaxTextureSize();

      FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

      crashlytics.log("failed to set texture of size "+bitmap.getWidth()+"x"+bitmap.getHeight()+" max is "+max);

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

// PUBLIC API

  public boolean isSolved()

    if( mSolvedFunctionIndex==0 ) return isSolved0();

    if( mSolvedFunctionIndex==1 ) return isSolved1();

    if( mSolvedFunctionIndex==2 ) return isSolved2();

    if( mSolvedFunctionIndex==3 ) return isSolved3();

    return false;

  public void setObjectRatio(float sizeChange)

    mObjectScreenRatio *= (1.0f+sizeChange)/2;

    if( mObjectScreenRatio>MAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE;

    if( mObjectScreenRatio<MIN_SIZE_CHANGE) mObjectScreenRatio = MIN_SIZE_CHANGE;

    float scale = mObjectScreenRatio*mInitScreenRatio*mNodeSize/mRealSize;

    mObjectScale.set(scale,scale,scale);

  public float getObjectRatio()

    return mObjectScreenRatio*mInitScreenRatio;

    }

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

  public int getCubitFaceColorIndex(int cubit, int face)

    {

    Static4D texMap = mMesh.getTextureMap(NUM_FACE_COLORS*cubit + face);

    int x = (int)(texMap.get0()/texMap.get2());

    int y = (int)(texMap.get1()/texMap.get3());

    return (mNumTexRows-1-y)*NUM_STICKERS_IN_ROW + x;

  public int getNumLayers()

    return mNumLayers;

    }

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

  public void continueRotation(float angleInDegrees)

    {

    mRotationAngleStatic.set0(angleInDegrees);

    }

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

  public void apply(Effect effect, int position)

    {

    mEffects.apply(effect, position);

  public void remove(long effectID)

    mEffects.abortById(effectID);

    }

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

  public synchronized void solve()

    {

      {

      CUBITS[i].solve();

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

      }

  public synchronized void beginNewRotation(int axis, int row )

    if( axis<0 || axis>=NUM_AXIS )

      {

      android.util.Log.e("object", "invalid rotation axis: "+axis);

      return;

      }

    if( row<0 || row>=mNumLayers )

      {

      android.util.Log.e("object", "invalid rotation row: "+row);

      return;

      }

    mRotAxis     = axis;

    mRotRowBitmap= computeBitmapFromRow( (1<<row),axis );

    mRotationAngleStatic.set0(0.0f);

    mRotationAxis.set( mAxis[axis] );

    mRotationAngle.add(mRotationAngleStatic);

    mRotateEffect.setMeshAssociation( mRotRowBitmap<<(axis*ObjectType.MAX_OBJECT_SIZE) , -1);

  protected abstract Movement getMovement();